PDF

1
AUTOMATIZACIÓN Y OPTIMIZACIÓN DE SISTEMAS DE

TRADING CUANTITATIVOS BASADOS EN EL INDICADOR
ICHIMOKU KINKO HYO.
LEIDY KATHERINE BUITRAGO RAMIREZ
UNIVERSIDAD PILOTO DE COLOMBIA.

FACULTAD DE INGENIERÍA
PROGRAMA INGENIERIA FINANCIERA
BOGOTÁ D.C 2017
2
AUTOMATIZACIÓN Y OPTIMIZACIÓN DE SISTEMAS DE

TRADING CUANTITATIVOS BASADOS EN EL INDICADOR
ICHIMOKU KINKO HYO.
LEIDY KATHERINE BUITRAGO RAMIREZ
Trabajo de grado para obtener el título de Ingeniera Financiera
Asesor: GIOVANNY MORENO BUITRAGO

Ingeniero Financiero.
DAVID RICARDO BALAGUERA MESA
Ingeniero Financiero.
UNIVERSIDAD PILOTO DE COLOMBIA.

FACULTAD DE INGENIERÍA
PROGRAMA INGENIERIA FINANCIERA
BOGOTÁ D.C 2017
3
Contenido
Resumen. ...................................................................................................................................................... 5
Abstract........................................................................................................................................................ 6
Introducción. ............................................................................................................................................... 7
Planteamiento del problema. ..................................................................................................................... 8
Objetivo general. ....................................................................................................................................... 13
Objetivo específico. ................................................................................................................................... 13
Justificación. .............................................................................................................................................. 14
Marco Referencial. .................................................................................................................................... 17
Antecedentes. ......................................................................................................................................... 17
Marco Teórico. ...................................................................................................................................... 21
Marco Conceptual................................................................................................................................. 24
CAPITULO 1. Estrategias de trading para la paridad EUR/USD a través de la optimización del
indicador Ichimoku Kinko Hyo e implementación de trading Algorítmico. ....................................... 29
Estrategia de trading. ........................................................................................................................... 31
Resultados. ............................................................................................................................................. 35
Propuesta de modelo Backtesting. ........................................................................................................... 38
Implementación de modelo a Python. ................................................................................................. 38
Cálculo del indicador técnico Ichimoku Kinko Hyo......................................................................... 40
Función de posición. .......................................................................................................................... 49
Función cierre .................................................................................................................................... 51
Función apertura. .............................................................................................................................. 53
Función de resultados. ....................................................................................................................... 54
Función agregar y escribir archivo.csv ............................................................................................. 55
Resultados. ............................................................................................................................................. 56
CAPITULO 2 Optimización de estrategias de inversión...................................................................... 61
Propuesta inicial nuevas estrategias de inversión. ............................................................................. 61
Aperturas. ........................................................................................................................................... 62
Cierres................................................................................................................................................. 66
Resultados de las estrategias planteadas. ............................................................................................ 72
Resultados finales. ................................................................................................................................. 84
Activo Funcional ....................................................................................................................................... 87
4
Descarga de Base Histórica de activos online ..................................................................................... 88

Base Histórica Adjunta......................................................................................................................... 90
CAPITULO 3. Interconexión plataforma de negociación Trader Workstation y lenguaje de
programación Python. .............................................................................................................................. 92
Métodos de conexión. ............................................................................................................................ 92
Pruebas envió de órdenes. .................................................................................................................... 97
Divisas. ............................................................................................................................................... 97
Acciones. ............................................................................................................................................ 98
Commodities. ..................................................................................................................................... 99
Bonos. ................................................................................................................................................. 99
Información Histórica. ....................................................................................................................... 101
Información Tiempo Real. ................................................................................................................. 104
Conclusiones. ........................................................................................................................................... 107
Anexos. ..................................................................................................................................................... 109
Anexo A. Diagrama de flujo modelo Backtesting Python. .............................................................. 109
Anexo B. Código cálculo Tenkan Sen................................................................................................ 109
Anexo C. Código cálculo Kinjun Sen. ............................................................................................... 111
Anexo D. Código cálculo Senkou Span A.......................................................................................... 112
Anexo E. Código cálculo Senkou Span B. ......................................................................................... 113
Anexo F. Código cálculo Chikou Span. ............................................................................................. 114
Anexo G. Código función posición..................................................................................................... 115
Anexo H. Código función cierre......................................................................................................... 117
Anexo I. Código función apertura. .................................................................................................... 120
Anexo J. Código función de resultados. ............................................................................................ 121
Anexo K. Código función agregar y escribir ................................................................................... 125
Anexo L. Código descargue información online. ............................................................................. 126
Anexo M. Código conexión y envió de órdenes. ............................................................................... 127
Anexo N. Código Información Histórica........................................................................................... 129
Anexo O. Código Información tiempo real. ...................................................................................... 130
Bibliografía .............................................................................................................................................. 131
5
Resumen.
Esta investigación propone un modelo Backtesting en el lenguaje de programación Python que
permite evaluar el desempeño de 30 estrategias propuestas para la paridad EUR/USD en el
marco de tiempo 15, 60, 240 minutos, obteniendo la configuración óptima para cada componente
del indicador técnico Ichimoku Kinko Hyo. Se presenta además un prototipo de interconexión
entre este lenguaje de programación y la plataforma de negociación Trader Worstation.

6
Abstract.
This research proposes a Backtesting model in the Python programming language that allows to
evaluate the performance of 30 proposed strategies for the EUR / USD parity in the time frame
15, 60, 240 minutes, obtaining the optimal configuration for each component of the Ichimoku
technical indicator Kinko Hyo. It also presents a prototype of interconnection between this
programming language and the trading platform Trader Worstation.

7
Introducción.
En esta investigación se propone la creación de un modelo Backtesting que permite validar,
actualizar y optimizar estrategias de inversión para la paridad EUR/USD bajo el indicador
técnico Ichimoku Kinko Hyo; adicionalmente se plantea un prototipo de interconexión entre el
lenguaje de programación Python y la plataforma de inversión Trader Workstation. El
documento se encuentra dividido en tres secciones:
Capítulo 1: En este apartado se presenta la creación del modelo Backtesting en el lenguaje de
programación Python que permite validar y actualizar los resultados obtenidos en estudios
anteriores.
Capítulo 2: En esta sección se puede evidenciar el proceso optimización de nuevas estrategias de
inversiones para la paridad EUR/USD con el indicador técnico Ichimoku Kinko Hyo teniendo
como filtro el lugar donde se produce el cruce entre los dos componente principales de este.
Capítulo 3: Se expone la manera mediante la cual se logra la interconexión con la plataforma de
negociación Trader Workstation y el lenguaje de programación Python, que permite a su vez la
recepción de información histórica, tiempo real y él envió de órdenes de mercado.

8
Planteamiento del problema.
En la actualidad, los trades al momento de abrir posiciones se enfrentan a tres inconvenientes: El
primero, la subjetividad en la toma de decisiones de inversión; el segundo, los riesgos operativos
asociados al operador que pueden materializarse en la disminución sustancial en las
rentabilidades esperadas para cada uno de ellos y por último, la desventaja de los operadores
“físicos” respecto a las ejecuciones automáticas generadas por algoritmos en cuanto a la
diferencia en el número de operaciones realizadas por unidad de tiempo (velocidad) y latencia de
ejecución.
Se han desarrollado proyectos que dan alguna visión de respuesta a estos problemas.
Investigaciones como “Análisis y comparativa de los sistemas automáticos de trading frente al
trading discrecionales” (del Rio Miño, 2015), concluyen que diversos factores emocionales como
la inseguridad, el miedo, la frustración, el estrés, la intuición, el cansancio, la distracción, la
soberbia, entre otras, desencadenan en la subjetividad en el proceso de toma de decisiones, en el
aumento de situación de riesgo operativos y por tanto en la utilidad obtenida por el trader.
En consecuencia, el posicionamiento de los sistemas automáticos ha venido aumentando
en las negociaciones de diferentes activos, tales como acciones y futuros en donde de acuerdo a
estudio como “High-Frequency trading-New Realities for Traders, Markets and Regulators”, se
estima que más del 60% de las operaciones se realizan a través de este tipo de trading y 40% en
el caso del mercado de divisas (Maureen , Lopéz de Prado, & Easley, 2013); evidentemente este
9
comportamiento también se encuentra relacionado con el tiempo de ejecución de órdenes
representado en milésimas de segundo por medio de algoritmos.
Este tipo de trading requiere de patrones objetivos en las variables involucradas en la
toma de decisión y es así como dentro del proceso de investigación se abordan el estudio de
“Estrategias de trading para la paridad EUR/USD a través de la optimización del indicador
Ichimoku Kinko Hyo e implementación del trading Algorítmico” del ingeniero David Balaguera
miembro del grupo de semillero de investigación ARISTOS del Programa de Ingeniería
Financiera de la Universidad Piloto de Colombia. En ésta, se realizó un modelo con algoritmos
que dan como resultado la configuración óptima de los parámetros para el indicador Ichimoku
Kinko Hyo, que permite la creación de una estrategia para la paridad Euro/Dólar, adicionalmente
se planteó el código en el lenguaje MQL4 para poder modificar el indicador en la plataforma
Metatrader 4.0.
Como consecuencia a los resultados positivos que arrojo la estrategia bajo las
configuraciones sugeridas, es importante evaluar nuevos escenarios y comportamientos del
indicador técnico Ichimoku Kinko Hyo que no han sido objeto de estudio, dar continuidad al
proceso de optimización de la estrategia permite aumentar el nivel de desempeño de la misma.

10
Si bien, la investigación de referencia, logra implementar la estrategia en el lenguaje de
programación MQL4 de la plataforma de negociación Metatrader 4, se considera pertinente
utilizar otro tipo de lenguaje que permita conservar la privacidad de las señales de apertura
(Mercado, Pending orders), las señales de cierre (Stop loss, Trailing stop, Take profit) y la
cantidad (Lotes) con la que se debe ingresar al mercado, estas son variables claves que se deben
involucrar a la estrategia de inversión; adicionalmente, se considera que el Bróker es la principal
contraparte y si se le brinda la identidad de cada una de las variables mencionadas anteriormente
el margen de superioridad para este sería superior frente al cualquier inversionista.
Por tanto, para la presente investigación será abordado el lenguaje de programación
Python, que es considerado el segundo más utilizado en los mercados (Piatetsky, 2013), esto
debido a las ventajas que ofrece como; la facilidad en la taxonomía de su lenguaje, además
brinda múltiples mecanismo para poder aprender sin dificultad la programación de este, y es una
herramienta de libre acceso.
Pretendiendo hacer un modelo asequible a varios sistemas operativos, se selecciona la
compañía Interactive Brokers como intermediario oficial de la investigación y la plataforma de
negociación Trader Workstation (TWS) como el medio por el cual se implementó la conexión
con el lenguaje de programación Python. Esta plataforma, ofrece otras ventajas competitivas
tales como: amplia variabilidad del portafolio de activos (acciones, divisas, índices,
commodities, bonos),ejecución instantánea de las ordenes, bajos costos de ejecución,

11
herramientas fundamentales y técnicas competitivas que permiten el seguimiento constante de
los instrumentos disponibles, trayectoria en el mercado y acceso abierto a la información por
medio de varios lenguajes de programación. A continuación se presenta un diagrama en el cual
se sintetiza de descripción del problema de investigación.
Descripción del problema de investigación.
Diagnostico. Causas. Pronostico. Control de pronostico.
Falta de evaluación Oportunidades nuevas de Es importante asumir los

nuevos escenarios del negocio. No se hacen publicos retos que exige la
indicador Ichimoku Kinko
abundantes estudios de resolución de problemas
Hyo para la paridad
análisis cuantitativos por medio de las
EUR/USD
profundos, con el fin de investigaciones
aportar soluciones académicas ya que se
efectivas a las pueden brindar
Inversion de manera problemáticas generadas oportunidades a los
discresional. a diarios en los mercados estudiantes que están
Subjetividad en la toma de financieros motivados a ser nuevos
decisiones de inversión investigadores a que
continúen en desarrollo
de proyectos que se han
realizado previamente
dando solución a
Perdidas económicas. situaciones reales, pero
que se puede seguir
Riesgo operativo avanzando en los
resultados o dando un
valor agregado adicional
Latencia.
Lenta ejecución
De acuerdo al planteamiento del problema la pregunta a resolver es ¿Cuál es el
desempeño (medido por rentabilidad, eficiencia y esperanza matemática), del indicador de

12
tendencia Ichimoku Kinko Hyo en la paridad EUR/USD en los marcos de tiempo de 15, 60 y 240
minutos, teniendo en cuenta los tres diferentes estados de la línea Kinjun Sen y la Tenkan Sen
respecto a la Kumo y cómo implementar esta estrategia en un programa que permita la
interconexión automática con la plataforma de negociación Trader Workstation?

13
Objetivo general.
Analizar el desempeño (medido por rentabilidad, eficiencia y esperanza matemática), del
indicador de tendencia Ichimoku Kinko Hyo en la paridad EUR/USD en los marcos de tiempo de
15 minutos, una hora y cuatro horas, en los tres diferentes estados en donde se puede presentar el
cruce de la Kinjun Sen y la Tenkan Sen respecto a la Kumo e implementar un programa que
permita la interconexión automática de la estrategia de trading con la plataforma de negociación
Trader Workstation.
Objetivo específico.
1. Crear un algoritmo en el lenguaje de programación Python que permita validar y
actualizar el desempeño del modelo realizado en la investigación principal de referencia.
2. Optimizar el algoritmo teniendo como referencia la posición del cruce de las líneas
Kinjun Sen y la Tenkan Sen respecto a la Kumo en el indicador técnico Ichimoku Kinko
Hyo.
3. Establecer la interconexión automática entre el lenguaje de programación Python y la
plataforma de negociación de Interactive Brokers.

14
Justificación.
La innovación y la tecnología es la clave para desarrollar los mercados financieros, pues han
logrado con éxito una transformación hacia mercados globales que tengan la capacidad de poder
operar más allá de los límites geográficos sin necesidad realizar inversiones físicas (Sánchez
Silva & Díaz Mondragón, 2007).
Anteriormente, la manera por medio del cual se tomaban las decisiones para invertir en
mercados financieros se basaban en la investigación y la intuición, ahora se conecta un algoritmo
directamente al mercado electrónico y las operaciones se calzan sin la intervención directa del
ser humano, esto producto del trading algorítmico. Los algoritmos pueden predecir más rápido y
con más precisión dónde se puede ganar dinero en los mercados cambiantes y completos como lo
son en la actualidad (British Broadcasting Corporation (BBC), 2016).
Siendo fieles al legado de la innovación y la tecnología se ha encontrado la manera de
crear metodologías de inversión que aporten agilidad, seguridad y confianza, para dar inicio a
nuevas oportunidades en los mercados financieros, no solo para realizar operaciones sino
también para encontrar escenarios óptimos donde puedan hacerse.

15
Se hace necesario realizar esta investigación puesto que será la solución a las
problemáticas identificadas en el planteamiento del problema, de no hacerlo seguirá existiendo
una necesidad de profundo cambio y la perdida de varios escenarios óptimos de inversión en los
mercados financieros.
La metodología de investigación que se implementó en el presente documento se basa en
el texto guía “Metodología, diseño y desarrollo del proceso de investigación” de Carlos E.
Méndez A. con el cual se define los criterios para desarrollar el proyecto con base en las
siguientes premisas:
Tipo de estudio: La presente investigación es de tipo exploratorio, el cual hace referencia
a la reunión de material bibliográfico que permite robustecer el marco teórico y los conocimiento
previos que se tienen de los temas claves de la investigación. Adicionalmente, el proyecto aborda
factores explicativos ya que la investigación también busca la comprobación del supuesto
inicialmente planteado como tema de investigación.
Método de investigación: Respecto al método de investigación, el planteamiento es
abordado desde lo experimental, el cual es definido como el conjunto de procesos que se deben
16
llevar a cabo para cumplir con los objetivos planteados y dar así una respuesta oportuna al
problema de investigación (Mendez,2011).
Recolección de información: se llevó a través del uso de fuentes primarias para diseño de
los códigos de programación, la recopilación de información del comportamiento del mercado,
los resultados arrojados de los procesos de Backtesting; y fuentes secundarias tales como libros,
Successful Algorithmic Trading (Halls Moore, 2015), documentos, Guia Trader Workstation.
(Interactive Brokers, s.f) , tesis (Balaguera Mesa, Estrategias de trading para la paridad
EUR/USD a través de la optimización del indicador Ichimoku Kinko Hyo e implementación del
trading algoritmico., 2015), etc.

17
Marco Referencial.
Antecedentes.
El estudio técnico de los mercados financieros surge a partir de las premisas expuestas por
Charles Dow en las décadas finales del siglo XIX, (Loaiza Palacios, 2007) cuya estructura
tomaba como base la descripción del comportamiento del mercado a partir de las gráficas de
cierre diario, lo cual implicaba que no tratara de prever comportamientos futuros si no por el
contrario, su intención era establecer una serie de patrones que se repetirían a partir de su
tendencia.
Con el surgimiento y evolución de las computadoras y el desarrollo de nuevas
tecnologías, el análisis técnico ha venido incorporando nuevas herramientas que mejoran los
resultados al momento de incursionar en el mercado financiero, uno de estos desarrollos es el
trading algorítmico.
El trading algorítmico se ha convertido en una herramienta fundamental en la
implementación de nuevos sistemas de negociación, basado en un fuerte contenido de análisis
técnico, soportado por cálculos matemáticos y desarrollos de códigos en lenguajes de
programación que permiten pronosticar a partir de la información histórica de un activo el
posible movimiento del mercado y por ende la futura tendencia sus precios, dejando de lado las
influencias emocionales que pueda tener el trader / inversionista, optimizando las decisiones de
negociación tomadas y su tiempo de ejecución.

18
El trading algorítmico ha sido puesto a prueba en un escenario optimo como lo es el
mercado de valores coreano, se ha encontrado que este tipo de negociación reduce los niveles de
volatilidad asimétrica que causa a su vez ineficiencia de la información, un aumento evidente en
la eficiencia del cierre de operaciones y adicionalmente un alto nivel de liquidez; se concluye
este estudio afirmando que en las bolsas de valores en las cuales son manejadas por
comunicaciones electrónicas sin intervención humana aumenta la calidad del mercado financiero
elevando el volumen de comercio de activos financieros (Seo & Chai, 2013).
También se han realizado estudios en los cuales se pone a prueba una de los bolsa más
grandes del mundo como lo es la de New York con la implementación de trading algorítmico, y
los resultados respaldan los hallazgos encontrados en otras investigaciones, las cuales afirman
que hay un aumento en la liquidez y además una mejor capacidad de proveer información acerca
de las cotizaciones del mercado (Hendershott, Jones, & Menkveld, 2011).
Sin embargo, existen nuevas posturas frente al tema, como lo es la investigación
“Optimal Trading Algorithms: Portfolio Transactions, Multiperiod Portfolio Selection, and
Competitive Online Search”, la cual propone la elaboración de códigos o algoritmos óptimos
para la negoción de los valores financieros y la mitigación de muchos factores por los cuales se
ven afectados los participantes del mercado; está es abordada desde varios puntos; en primer
lugar, la aversión del riesgo que está interpretada como los momentos por los cuales debe pasar
19
un inversor cuando quiere realizar una operación de mercado pero este no cuenta de inmediato
con las disponibilidad del total de los activos que el inversionista desea adquirir, por tanto esta
orden de mercado es trabajada a ciertos periodos de tiempo exponiéndose a la volatilidad que se
pueda generar y el riesgo de mercado por la ejecución lenta. En segundo lugar, se postula un
comercio adaptado a la apreciación de precios, es decir, cómo los grandes inversores de mercado
toman sus decisiones de inversión durante la noche o en la madrugada y en el día se dedican a
negociar, la apreciación de precios en las primeras horas de negociación indica las grandes
posiciones netas que se están ejecutando y por consiguiente se genera este impulso de precios;
con estas ideas se plantea un modelo matemático y algorítmico que busca la reducción de los
costos totales de negociación y mitigue los riesgos a los cuales se está expuesto al momento de
invertir; con este tipo de investigación se propone ser más exigente con la función que tiene el
trading algorítmico pues no es solo que ejecute gran cantidad de ordenes sino que a su vez
beneficie al inversor con la reducción de factores que podrían llegar a impactar de manera
negativa el rendimiento de su capital financiero (Lorenz, 2008).
Adicionalmente, se han realizado modelos matemáticos de media varianza que pueden ser
incorporados a ciertas estrategias de inversión, que busca encontrar un equilibrio en el costo del
inversor cuando la ejecución rápida de sus órdenes contra el riesgo de volatilidad por la
ejecución lenta. Aplicando este modelo se reduce el riesgo que se genera por la aceleración de la
ejecución de los órdenes cuando el precio se mueve a favor del comerciante, y así encontrar el
precio de entrada más rentable por medio del trading algorítmico (Almgren & Lorenz, 2007).
20
Por otro lado, hay investigaciones como “Moore's law versus Murphy's Law: Algorithmic
trading and its discontents”, donde se reconoce que los mercados financieros hoy en día están
siendo consumidos por la tecnología y en especial por el trading algorítmico, como
consecuencia a ellos los beneficios para los participantes del mercados son evidentes en cuanto a
la rapidez de las ejecuciones de las operaciones, entre otras; pero se advierte que puede llegar a
tener problemas pues no es algo que se encuentre regulado y se propone la “Regla Financiera
2.0”, que consiste básicamente en crear mecanismos que ayuden a la regulación de los mercados
automatizado, pues se cree que esto aportaría más confianza y seguridad a los inversores al
momento de ingresar al mercado (Kirilenko & Lo, 2013).

21
Marco Teórico.
En esta sección se pretende mencionar los documentos que tuvieron más relevancia para el
desarrollo de la presente investigación.
El Ichimoku Kinko Hyo es un indicador con gran acogida por quienes a diario interactúan
en los mercados de valores, debido a su versatilidad, pues permite definir niveles de soportes,
resistencias, así como también identificar cambios de tendencia y con esto señales de entrada o
salida en el mercado de alta probabilidad de ganancias. Este indicador se ajusta a cualquier
marco de tiempo y a cualquier activo de negociación, ya sea acciones, divisas, índices,
commodities, opciones y futuros; pero ya que este es un indicador de tendencia se ajustara mejor
a los mercados que estén caracterizados por esto (Admiral Markets AS, s.f)
La comprensión de la funcionalidad del indicador técnico Ichimoku Kinko Hyo puede en
principio ser compleja, esto como consecuencia a la cantidad de parámetros que lo compone y el
significado de cada uno de ellos, para el manejo parcial de este, se tiene como guía el libro
“Trading with Ichimoku cloud. The Essential Guide to Ichimoku Kinko Hyo Technical
Analysis” (Patel, 2010) que no solo aporta una amplia descripción sobre el manejo de cada
componente del indicador, sino que adicionalmente brinda herramientas para el desarrollo de
Backtesting eficiente, esto es útil en esta investigación para comprobar si basados en los
comportamientos históricos de este indicador y bajo los filtros propuestos en secciones pasadas,
22
el desempeño de la estrategia de trading aumenta su desempeño. Adicionalmente, tiene un
amplio contenido en el análisis luego de obtener los resultados del Backtesting y cómo poder
adaptar una estrategia de inversión consistente y rentable.
Por otro lado, la principal investigación que será tomada como referencia será la
desarrollada en el Programa de Ingeniería Financiera de la Universidad Piloto de Colombia
correspondiente a “Estrategias de trading para la paridad EUR/USD a través de la optimización
del indicador Ichimoku Kinko Hyo e implementación del trading Algorítmico.” (Balaguera
Mesa, Estrategias de trading para la paridad EUR/USD a través de la optimización del indicador
Ichimoku Kinko Hyo e implementación del trading algoritmico., 2015) En la cual como se ha
venido mencionando, se realizó el desarrollo de estrategias de inversión con base a la
configuración óptima arrojada por el algoritmo. Se tomó para este proyecto el modelo realizado
en esta investigación y esto permitirá poder comparar los resultados conseguidos por el
investigador Ricardo Balaguera, frente a los que se obtendrán en el presente estudio y poder
determinar si los nuevos filtros establecidos fueron ideales para continuar con el proceso de
optimización del desempeño de la estrategia de trading.
Para poder establecer la conexión desde el lenguaje de programación Python y la
plataforma de negociación de Interactive Brokers, se tiene como referencia el libro “Successful
Algorithmic Trading” (Halls Moore, 2015), el cual brinda una guía sobre la introducción al
23
trading algorítmico, conceptos sobre sistemas de trading y como poder implementar un sistema
eficiente de desarrollo de estrategias y comercio electrónico.
Además, para el desarrollo de esta se tuvo como referencia una guía online ofrecida
directamente por la plataforma de negociación de Interactive Brokers, que cuenta con la
ejemplificación de varias funciones que se ofrece a los inversores en diferentes lenguajes de
programación como lo es, C#, Java, Visual Basic, C++ y por último Python (Interactive Brokers,
s.f).
24
Marco Conceptual.
A continuación se definirán algunos conceptos claves que ayudaran a comprender todo el
desarrollo de la investigación.
El trading algorítmico es un mecanismo de inversión, el cual consiste en codificar las
estrategias de cada inversor en un lenguaje de programación, de tal forma que las operaciones se
realizaran de manera automática siempre y cuando exista una conexión con los mercados
financieros.
Por otro lado, es importante entender que cuando se habla de plataforma de negociación
se hace referencia a un lugar no físico por medio del cual se ejecutan las operaciones de compra
y venta de un activo financiero, y suministra en tiempo real los precios de los valores que se
desean negocia.
En cuanto al lenguaje de programación Python, se define como el lenguaje de
programación por medio del cual se pretende realizar la interconexión con la plataforma de
negociación, que brinda seguridad y rapidez al momento de la ejecución.

25
Por otra parte, los indicadores técnicos, son herramientas que se utilizan para el análisis
técnico, se agrupan generalmente en tres tipos: volumen, osciladores y de tendencia; dentro de
esta última categoría se encuentra un indicador el Ichimoku Kinko Hyo el cual sirve para
determinar la tendencia del mercado, posibles niveles de soportes y resistencias que generan
señales de compra y venta. Este indicador está compuesto por lo siguiente:
 Tenkan-Sen muestra el valor medio del precio durante el primer periodo de tiempo, se
determina como la suma del máximo y el mínimo durante este tiempo divida por dos.
Tenkan Sen
Figura 1. Tenkan Sen: se puede evidenciar la línea Tenkan Sen. Fuente: Metatrader 4.0 (2017)
 Kinjun-Sen muestra el valor medio del precio durante el segundo periodo de tiempo.
Tenkan Sen
Kinjun Sen
26
Figura 2. Kinjun Sen: Se puede evidenciar construcción de las líneas Tenkan Sen y Kinjun Sen.
Fuente: Metatrader 4.0 (2017)
 Senkou Span A muestra la mitad de la distancia entre dos líneas anteriores, que esta
desplazada hacía adelante al valor del segundo periodo de tiempo.
 Senkou Span B muestra el valor medio del precio durante el tercer periodo de tiempo que
ha sido desplazado hacia adelante al valor del segundo periodo de tiempo.
Tenkan Sen
Kinjun Sen
Senkou Span B
Senkou Span A
Figura 3. Senkou Span A - Senkou Span B: Se puede evidenciar construcción de las líneas
Tenkan Sen, Kinjun Sen, Senkou Span A, Senkou Span B. Fuente: Metatrader 4.0 (2017)
 Chikou Span muestra el precio de cierre de la vela actual que está desplazada hacia atrás
al valor del segundo período de tiempo. La distancia entre las líneas Senkou en el gráfico
se raya en otro color y se llama "nube". Si el precio se encuentra entre estas dos líneas, se
considera que al mercado le falta tendencia y entonces los bordes de la nube forman los
niveles de soporte y resistencia. (Metatrader, 2016)

27
Chikou Span
Tenkan Sen
Kinjun Sen
Senkou Span B
Senkou Span A
Figura 4. Indicador Técnico Ichimoku Kinko Hyo: se puede evidenciar todos los componentes
del indicador técnico. Fuente: Metatrader 4.0 (2017)
Cuando se habla de Backtesting se hace referencia a un proceso mediante el cual se estudia una
estrategia de inversión antes de emplearla oficialmente para operar en el mercado, esto permitirá
conocer si lo que se plantea es correcto y ha tenido buenos resultados en un marco de tiempo
determinado (Instituto de Inversiones Bursatiles y Trading , s.f)

28
Se define como estrategia de inversión a la especificación de las señales de apertura y
cierre, confirmación, Take profit, Stop Limit, Trailing stop, cantidad de lotes, con las cuales un
inversionista debería ingresar al mercado, con el fin de tener un máximo rendimiento frente a un
mínimo nivel de riesgo.

29
CAPITULO 1.
Estrategias de trading para la paridad EUR/USD a través de la optimización del indicador
Ichimoku Kinko Hyo e implementación de trading Algorítmico.
En este capítulo se presenta la creación del modelo Backtesting en el lenguaje de programación
Python, que permite validar y actualizar los resultados obtenidos en el estudio principal de
referencia. Esta investigación tuvo como objetivo principal, poder evaluar la eficiencia,
rentabilidad y confiablidad de las estrategias de inversión basadas en el indicador técnico
Ichimoku Kinko Hyo en la paridad Euro/ Dólar en los marcos de tiempo de 15, 60 y 240
minutos, tras un proceso de optimización de parámetros y la aplicación de estos en un prototipo
de trading algorítmico implementado en el lenguaje MQL4 (Balaguera Mesa, Estrategias de
trading para la paridad EUR/USD a través de la optimización del indicador Ichimoku Kinko Hyo
e implementación de trading Algoritmico., 2015) .
La manera en la cual se desarrolló este estudio, fue por medio de la creación de un
modelo en Visual Basic, que permite hacer un número de combinaciones posibles para cada uno
de los parámetros del indicador técnico dependiendo de los rangos asignados para el estudio, y
que a su vez por cada configuración realizada genera un nuevo archivo con información
calculada acerca de los componentes del indicador (Tenkan Sen, Kinjun Sen, Senkou Span A,
Senkou Span B), posición de mercado con base a la estrategia de inversión, cierre y apertura de
la misma, resultado posiciones cortas y largas, datos estadísticos sobre el comportamiento de la
estrategia de acuerdo a cada configuración.

30
Hoja "PRECIOS"
Calculo del Ichimoku Kinko
Rango de parametros. Hyo.
Tenkan Sen, Kinjun Sen, Tenkan Sen, Kinjun Sen, Senkou
Senkou Span B, Span B, Adelantamiento de Nube
Hoja "Resultado Corto"

Precios Metatrader.
Base de datos Resultado posiones cortas
Archivo resultante. Apertura, Cierre, Resultado
Creador Blacktesting.
Precio, Resultado Corto,
Rutas, parametros
Resultado Largo, Resultado
Informe Resultante Hoja "Resultado Largo"
Resultado posiones largas
Hoja "Informe General"
Apertura, Cierre, Resultado
Resumen por configuración de
parametros.
Informe Base. Resultado total, N° de trade, Hoja "Resultado Historico"
Trade positivos y negativos, Resumen Anual y mensual,
Eficiencia, Maximo, Minimo, Estadisticas.
Promedio, Desviación. Resultado total, N° de trade,
Maximo, Minimo, etc.
Figura 5. Diagrama del modelo. Se puede observar en el gráfico la manera mediante la cual
realiza los procedimientos el archivo al ser ejecutado, para su correcta ejecución se requiere de la
ubicación de tres archivos y los parámetros asignados, de esta forma se podrá utilizar esta
información para crear un nuevo archivo resultante con los cálculos antes mencionados, a su vez
los resultados obtenidos servirá para complementar el archivo principal. Fuente: Creación propia
(2017).
Estas últimas cifras obtenidas al final de cada archivo resultantes, son recopiladas
nuevamente en el archivo principal (“Creador Backtesting”), con el fin de brindar un informe
general sobre el desempeño que ha tenido la estrategia por cada configuración realizada dentro
del rango de datos dados por el usuario, esto brinda la facilidad al operador para el análisis de las
cifras y así poder tomar una dedición sobre la configuración con la cual se ajusta más el
indicador en el mercado, en cuanto a resultado y eficiencia.

31
Por otro lado, en la plataforma de negociación Metatrader 4.0 se realizó un Expert
Advisor que permite la una apertura o cierre, de posiciones de manera automática si el
comportamiento del mercado se ajusta a la estrategia programada, para esto es necesario poner la
configuración de los parámetros óptimos que arroja el análisis de los resultados del programa
realizado en Visual Basic.
Estrategia de trading.
La estrategia de inversión consiste principalmente en el rompimiento de la nube conformada por
dos parámetros del indicador técnico, por la línea Kinjun Sen; la confirmación de entrada se dará
con el comportamiento del precio. Se presenta señal de compra, cuando la línea Kinjun Sen
rompe la línea superior de la nube hacia arriba, se tomará posición con la apertura de la vela que
se encuentre por encima de la misma, en caso de que el precio sea inferior al Kumo se deberá
esperar hasta que este se ubique sobre la nube (Véase Figura 4).
32
Figura 6. Señal de compra. Es evidente el rompimiento que hace Kinjun Sen a la nube. Fuente:
Metatrader 4.0 (2017)
Cuando se presenta lateralidad en el comportamiento de la Kinjun Sen y esta a su vez se empieza
a ubicar debajo del Kumo, haciendo un rompimiento hacia abajo y dando señales de una posición
de venta, pero dado que la apertura aún no se ubica debajo de la nube no se confirma esta señal.
La señal de venta se presenta, cuando la Kinjun Sen atraviesa la parte inferior de la nube
y la apertura de la vela se encuentra también bajo el Kumo (Véase Figura 5). De igual manera se
puede presentar lateralidad en el comportamiento de la Kinjun Sen y será necesario esperar a que
se cumpla con la totalidad de los requisitos para poder abrir la posición.

33
Figura 7. Señal de Venta. Se realiza el rompimiento de la nube la Kinjun Sen, dando una señal
de venta. Fuente. Metatrader 4.0 (2017)
Para abrir cualquier tipo de posición larga o corta, es necesario esperar la confirmación de la
misma, que consiste en una nueva apertura de vela por encima o debajo de la nube
respectivamente (Véase Figura 6).
Apertura
Cierre
34
Figura 8. Señal y confirmación para apertura y cierre de la posición. Se evidencia cómo en
el primer recuadro color rojo se encuentra el precio sobre la nube y adicionalmente se encuentra
el rompimiento de la Kinjun Sen, se identifica entonces una señal de compra; en el segundo
recuadro de color violeta se observa la confirmación para la apertura de la orden. En los
recuadros verde y azul al finalizar la imagen se puede apreciar cómo entra el precio a la nube
dando una señal de cierre de posición y cómo en la siguiente vela hace su ingreso la Kinjun Sen
para confirmar el cierre de la operación de compra.
Es importante resaltar que la estrategia de trading se encuentra diseñada para que solo se
encuentre una posición abierta a la vez, puesto que el cierre de alguna de estas puedes
desencadenar directamente en la apertura de otra nueva.
Recapitulando de manera general la descripción de la estrategia de trading, para una
operación de compra, la señal se presentará en el momento que la Kinjun Sen sea mayor que la
nube compuesta por la Senkou Span A y Senkou Span B, la confirmación en este caso será la
primer vela cuya apertura sea mayor que el Kumo, la apertura de la posición será entonces
cuando el open de la primera vela se haya presentado de igual forma sobre la nube y a su vez se
cumplan los comportamientos de señal y confirmación, el cierre de posición en cambio se dará
cuando la Kinjun Sen se encuentre dentro del Kumo y exista una apertura dentro de la nube.
35
Para el caso de una operación de venta, la señal ocurrirá cuando la Kinjun Sen es menor
al Kumo, se confirma cuando la apertura de la vela se encuentra por debajo de la nube, y se abre
la operación cuando la apertura de la primera vela es menor a la Senkou Span A y Senkou Span
B, por supuesto luego de haber sido evaluada la señal y la confirmación, el cierre será el mismo
para ambas posiciones.
Resultados.
Se realizó una comparación de resultados obtenidos por la configuración por defecto de los
parámetros del indicador técnico Ichimoku Kinko Hyo (los valores que tiene predeterminados el
indicador para cada uno de sus componentes) y la configuración propuesta (nuevos valores
sugeridos para cada componente del indicador) por el modelo, tomando las siguientes cifras:
Tabla 1. Configuración del indicador técnico:
Parametros
Configuración Configuración
Componente
por defecto propuesta.
Tenkan Sen 9 8
Kinjun Sen 26 22
Adelantamiento 26 22
Senkou Span B 52 44
Nota: Se ven reflejado los valores propuestos y traídos por defecto. Fuente: Creación propia
(2017).
36
Al evaluar estos parámetros y en los marcos de tiempo de 15,60 y 240 minutos, se puede afirmar
que fue más rentable la configuración propuesta para todos los marcos de tiempo, dejando como
resultado 4145.2, 12153.9 y 16169.2 respectivamente, mientras que en la configuración que trae
por defecto el indicador el resultado de rentabilidad fue de 2542.8 para el marco de tiempo de 15
minutos, 10741.5 para 60 minutos y 15023.9 para 240 minutos.
Se realizó además un mapa de calor para cada marco de tiempo y poder evidenciar las
zonas en las cuales se producía una mayor acumulación de rentabilidad, así como también los
máximos trades alcanzados por configuración, mayor rendimiento promedio evaluando en cada
mapa los parámetros Senkou Span B y el adelantamiento de la nube, también se tuvo en cuenta el
análisis del comportamiento del promedio frente a los máximos registrados por configuración.
En términos generales, los resultados que se obtuvieron al realizar el estudio en el marco
de tiempo de 15 minutos fueron, cuando el adelantamiento de la nube tiene un rango entre 4 a 23
desplazamientos, el valor de la Tenkan Sen es mayor a 7 periodos y los de la Kinjun Sen se
encuentran entre los 10 y 15 periodos, al comparar el parámetro de adelantamiento de la nube
con el parámetro de la Senkou Span B se observó que se generan la mejor zona óptima para el
promedio del resultado en pips.

37
Para el marco de tiempo de 60 minutos el desempeño de la estrategia funcionara mejor si
el desplazamiento de la nube es superior a 20 periodos, pues aquí se encuentran los mejores
máximos en cualquier configuración del Senkou Span B, los periodos de la Kinjun Sen se deben
encontrar entre 10 y 15 y los de la de Tenkan Sen entre 6 y 10 periodos.
La implementación del programa de trading algorítmico es importante, debido a un gran
avance en el enrutamiento de órdenes y latencia de ejecución, a su vez ofrece un beneficio
adicional como la velocidad en la ejecución de posiciones al mercado.

38
Propuesta de modelo Backtesting.
Después de evaluar el modelo Backtesting realizado en la investigación principal de referencia,
es oportuno poder aumentar la velocidad de ejecución, pues esto permitirá que sean evaluados
múltiples escenarios del mercado en el menor tiempo posible, y de esta manera aprovechar
oportunidades de inversión, por este motivo se propone a continuación un modelo Backtesting en
el lenguaje de programación Python.
Implementación de modelo a Python.
El modelo propuesto, realizará el cálculo del indicador técnico Ichimoku Kinko Hyo, de acuerdo
al rango de los parámetros establecidos por el usuario, automáticamente procesará las
combinaciones posibles y procederá a calcular cada uno de los componentes del indicador
técnico, con base a esto indicará la posición que debe tomar teniendo inicialmente la estrategia
de inversión propuesta y la cual fue expuesta en secciones anteriores, adicionalmente, mostrará
apertura y cierre de posiciones, para finalmente concluir con los resultados obtenidos del estudio
tales como: Resultado total, número de trade positivos y negativos posiciones cortas, número de
trade positivos y negativos posiciones largas, total de trade, eficiencia, trade máximo y mínimo,
promedio de trade; y la creación de un archivo “.csv” con la información calculada.

39
Después de realizar cada combinación, el programa guardará los resultados obtenidos
para luego almacenarlos en un nuevo archivo “.csv”, el cual será generado al finalizar la
ejecución completa por activo, esto permite el análisis conjunto de las cifras producto de cada
combinación.
El desarrollo de este programa se basó en la creación de funciones y al final un método
principal que es el encargado de llamar a cada una de ellas y de esta manera ejecutar el modelo
más rápido. La metodología por la cual se realiza lectura de la información en Python es por
medio de ciclos repetitivos.
Es importante resaltar que antes de ejecutar el programa, se debe tener en la misma carpeta o
directorio donde está almacenado este, un archivo “.csv”, con la información histórica que se
desea analizar, y suministrar el nombre exacto de este al programa para que pueda compilar de
manera satisfactoria. El orden que deben tener los datos dentro de este archivo es: la fecha, la
hora, open, high low, close y volumen, tal como se muestra en la siguiente:
40
Figura 9. Formato de presentación archivo entrante. Se puede observar el orden que debe
tener el archivo para poder ingresar al programa. Fuente: Excel (2017)
Un diagrama general en el cual se observa el planteamiento de todo el modelo, se
encontrará en los anexos del presente documento (Anexo A). Para poder explicarlo de manera
más clara se dividirá en seis categorías: Cálculo del indicador técnico Ichimoku Kinko Hyo,
Posición, Cierre, Apertura, Cálculos de rendimientos, Escribir nuevo archivo.
Cálculo del indicador técnico Ichimoku Kinko Hyo.
Para dar a conocer de manera más clara el funcionamiento del modelo, se plantea un diagrama de
flujo (Figura 7), en el cual se muestra el proceso de ejecución interna de la primera parte del
modelo propuesto, empezando por recorrer una función que lee el archivo, luego haciendo el
cálculo de la Tenkan Sen, seguido de la Kinjun Sen, posteriormente el adelantamiento, más
adelante la Senkou Span B y finalizando por el Chikou.

41
ARCHIVO PLANO CSV.

Fecha, Fecha, Open, High,
Low, Close.
Def Leer_archivo.
archivocsv.
Def Tenkan. Def Kinjun. Def spanb.

archivocsv, par_tenkan. archivocsv, par_kinjun. archivocsv, par_spanb.
lista_tenkan [ ] lista_kinjun [ ] lista_spanb [ ]
Def spana.
Def Chikou.
par_tenkan,
archivocsv, par_ade.
par_kinjun,par_ade.
lista_chikou [ ] lista_spana [ ]
Figura 10. Diagrama de flujo cálculo del indicador técnico Ichimoku Kinko Hyo. Se observa
el orden de ejecución de la primera sección del programa. Fuente: Creación propia (2017).
Es pertinente volver a resaltar que antes de ejecutar el programa de Python se debe contar
en el mismo directorio con un archivo “.csv” que contenga la información histórica de la paridad
en el marco de tiempo deseado.
Si dentro de las opciones avanzadas de Excel del usuario, se encuentra configurado el
separador decimal “,” (Signo de puntuación coma) y como separador de miles “.” (Signo de
puntuación punto), deberá abrir el archivo “.csv” en un bloc de notas y reemplazar en primer
lugar las “,” (Signo de puntuación coma) por “.”(Signo de puntuación punto), y en segundo lugar
42
los “;”(Signo de puntuación punto y coma) por “,” (Signo de puntuación coma); esto con el fin
de que el Python pueda reconocer la información del archivo correctamente y pueda compilar.
En la parte final del programa de Python, se encontrará el menú principal que como se
mencionaba en secciones anteriores es el lugar en donde se invocan las funciones creadas, esto
para aportar agilidad al ejecutarse; la primera sentencia que se encontrara allí será:
archivocsv = Leer_archivo (" .csv")
Así pues, se está invocando la función “Leer_archivo”, pero a su vez esta exige que se
ingrese el nombre del documento para poder ejecutarse, es entonces en la línea verde, donde
debe ponerse el nombre del archivo en el cual se encuentra almacenado el histórico de precios.
La parte azul, representa el nombre que se le asigna a lo retornado por la función que se invoca.
def Leer_archivo(csv_file):
return datalist
Las funciones en Python se identificaran porque inician con “def”, expresión que se usa
para crearlas en este lenguaje de programación. El texto anterior simboliza de manera general la
43
función “Leer_archivo” y como se puede apreciar exige una entrada, que es demarcada de color
verde, es entonces cuando el nombre del archivo ingresado en el menú principal será lo necesario
para poder compilar la función y retornar lo que se denomina “archivocsv”. Para poder
desarrollar esta función fue necesario acudir a la guía desarrollada por Python para facilitar la
interacción con el lenguaje de programación. (Python Software Foundation., 2017)
Antes de ser ejecutado el programa, el usuario deberá asignar el rango para cada uno de
los parámetros, dentro del código de Python el lugar donde se define esto, es a continuación
donde se enuncia la función que se explicó anteriormente, allí se encontraran ocho variables
diferentes (ti,tf,ki,kf,ai,af,bi,bf), la primer letra hace referencia al parámetro (t = Tenkan Sen,
k=Kinjun Sen, a=Adelantamiento de la nube, b=Senkou Span B), y la variable posterior significa
inicio o fin; es decir, “ti” significa el parámetro con el cual desea iniciar el rango de
configuraciones posibles para la Tenkan Sen, y “tf” el parámetro con el cual finalizará; y así para
cada componente del indicador técnico Ichimoku Kinko Hyo.
Para asignar de manera correcta los parámetros es necesario tener en cuenta lo siguiente,
en el lenguaje de programación Python al definir un rango, este no tiene en cuenta el último valor
suministrado, por ejemplo: si se desea que las configuraciones de la Kinjun Sen inicien en dos y
finalice en cinco, entonces el valor se debe asignar a “ki”=2 y a “kf”=6, para que de esta manera
44
el programa pueda establecer el rango para la Kinjun Sen desde dos hasta cinco; así para la
asignación de todos los rangos de cada componente.
Posterior a esto se encontrará la manera como se convierten estos rangos asignados en
listas y un ciclo que realiza el número de combinaciones posibles teniendo como referencias los
datos suministrados, luego de esto se observa la creación de unas variables que son necesarias
para el almacenamiento de información y otras que cumplen la función de contadores.
Como siguiente sentencia, se evidenciará la creación de ciclo repetitivo “for”, cuya
función es realizar el cálculo del indicador técnico para cada configuración posible, dentro de
este se encuentra la lectura de las listas en donde están almacenadas cada combinación posible,
para extraer un elemento a la vez de cada una de ellas, luego de esto una creación de lista, cuyo
objetivo será almacenar cada resultado producto del análisis por configuración. Posterior a esto
se continúa con el proceso de invocación de funciones que hacen posible el cálculo del indicador
técnico Ichimoku Kinko Hyo.

45
Después de leer el archivo, se remitirá a sentencia del menú principal, en la que se invoca
la función “tenkan” que realiza el cálculo del componente Tenkan Sen del indicador técnico
Ichimoku Kinko Hyo.
lista_tenkan, par_tenkan, total_high, total_low=tenkan(archivocsv)
Aquí, se evidencia que lo retornado en la primera función y denominado “archivocsv” es
ahora utilizado en la función tenkan para realizar su cálculo y retorna unos valores almacenados
en listas, demarcados en ese ejemplo de color azul.
def tenkan (lista_precios):
return lista_tenkan, par_tenkan,total_high,total_low
Ahora la función “tenkan”, recorrerá el archivocsv y abstraerá los valores de High y Low
almacenándolos en una lista independiente a cada uno, posteriormente preguntara al usuario el
parámetro para este componente y realizará el cálculo, finalmente retornara los valores
almacenados en lista de “lista_tenkan”, es donde se almacenaron cada uno de los datos
calculados por el función, “par_tenkan”, nombre asignado al valor dado por el usuario,
“total_high” y “total_low”, listas en donde se guardan los valores extraídos del archivo principal
que contiene información histórica. (Anexo B).

46
Para invocar la función que realizará el cálculo de la línea Kinjun Sen, en el menú
principal la sentencia que realiza este procedimiento es:
lista_kinjun, par_kinjun=kinjun(archivocsv,total_high,total_low)
Nuevamente, lo retornado por la primer función invocada (“Leer_archivo”) es requerido
en este caso, para extraer información necesaria para el cálculo, así como también ingresan las
listas provenientes de la función Tenkan es decir “total__high” y “total_low”; se tendrá entonces
que esta función kinjun devolverá la “lista_kinjun” y el valor “par_kinjun”.
def kinjun(lista_precios,total_high,total_low):
return lista_kinjun,par_kinjun
El objetivo de función “kinjun” es realizar el cálculo de los valores de la línea Kinjun
Sen, la manera mediante la cual se procesa esta instrucción es teniendo como entrada lo
designado anteriormente en color verde es decir la “lista_precios”, “total_high”, “total_low”,
luego de que recibe la información el programa preguntará al usuario un valor para el parámetro
kinjun, en las siguientes líneas de código de la función se realizará el cálculo y se almacenará el
resultado de cada operación en “lista_kinjun” que será lo retornado por la función junto al
“par_kinjun”. (Anexo C).

47
El siguiente componente del Ichimoku Kinko Hyo a calcular será el Adelantamiento de la
nube o la línea Senkou Span A, esta función “spana” se retroalimenta de “lista_tenkan” que fue
retornada por la función “tenkan”, también de “lista_kinjun” y “par_kinjun” ambos valores
devueltos por la función “kinjun”, la invocación de esta nueva función se encontrara en el
método principal como:
lista_spana,par_ade=spana(lista_tenkan,lista_kinjun,par_kinjun)
El cálculo de cada valor de la línea Senkou Span A, se realiza teniendo en cuenta los
valores de resaltados anteriormente de color verde, de manera simultánea es necesario el ingreso
del parámetro de adelantamiento por el usuario, para poder realizar las operaciones, cada valor
resultante de estas será agregado a una lista de almacenamiento denominada “lista_spana”;
siendo este uno de los valores devueltos junto a la variable en la que fue almacenado el
parámetro para este componente (“par_ade”). (Anexo D).
def spana(lista_tenkan,lista_kinjun,par_kinjun):
return lista_spana, par_ade

48
Para invocar la siguiente función que dará como resultado una lista con datos producto
del cálculo de la línea Senkou Span B, la sentencia de código en el método principal del
programa será.
lista_spanb,par_spanb=spanb(par_ade,archivocsv,total_high,total_low)
Como se ha explicado antes, lo que se encuentra dentro del paréntesis hace referencia a lo
que necesita la función para poder ejecutarse, para este caso en concreto, los valores o listas
necesarias, han sido producto de los retornos de funciones explicadas anteriormente.
def spanb(par_ade, lista_precios,total_high,total_low):
return lista_spanb , par_spanb
La ejecución de esta función tiene la misma lógica que ha tenido las explicadas
anteriormente, se nutre de unos valores que deben ingresar y que para hacer más fácil la
comprensión se han resaltado de color verde, posteriormente el ejecutable pedirá al usuario la
asignación de un valor al parámetro Senkou Span B, y a partir de este momento se realizará el
cálculo que simultáneamente con su desarrollo ira agregando en una nueva lista (“lista_spanb”)
para luego ser retornada por la función, junto a “par_spanb” variable que guarda el valor del
parámetro ingresado de este componente. (Anexo E).

49
La sección del programa de Python que fue creada para el cálculo del componente
Chikou Span o también denominada línea del precio retardado, se retroalimentará del archivo
retornado en la primera función explicada y del valor dado al parámetro de adelantamiento
denominado en este caso “par_ade”, que fue la variable devuelta en la función “spana”, si bien
en esta nueva función se hace los procedimientos para toda la lista de datos y a su vez van siendo
almacenados en una lista denominada “chikou”, este función no retornara ningún valor. (Anexo
F). La sentencia en el menú principal que la invoca es:
chikou(archivocsv,par_ade)
Con los seis procedimientos explicados anteriormente se completa el cálculo de cada uno
de los componentes del indicador técnico Ichimoku Kinko Hyo, es pertinente recordar que a esta
etapa de ejecución del programa, los valores calculados para cada uno de estos están
almacenados en diferentes listas y que serán utilizadas en funciones posteriores para poder
realizar el Backtesting.
Función de posición.
El objetivo de este apartado es explicar la manera mediante la cual se identifica la posición que
se debe tomar, sea corta o larga, dependiendo del comportamiento del mercado en cada
momento. Para que la explicación sea más grafica se presenta a continuación un diagrama de
flujo que simboliza de manera general el procedimiento de ejecución de la función.

50
Def posicion_lc.
archivocsv,par_tenkan,
par_kinjun,lista_spana,
lista_spanb.
O,SA,SB,K
,posicion SI CORTO
LARGO
posicion [ ]
NO
""
Figura 11. Diagrama de flujo función “posición_lc”. Se muestra de manera gráfica la
ejecución de este procedimiento. Fuente: Creación propia (2017).
En el método principal la sentencia por medio del cual invoca esta función es:
total_open, total_close, posicion=posicion_lc(archivocsv,lista_kinjun,lista_spana,lista_spanb)
Es decir, la función “posición_lc” se alimentará de algunos retornos de las funciones que
se han explicado anteriormente, y los valores que devolverá esta función en concreto serán los
demarcados de azul.
51
En concreto el desarrollo de la función está fundamentada inicialmente en la extracción
de información referente a los datos de fecha, Open y Close de la base de datos inicialmente
suministrada, posteriormente mediante un ciclo repetitivo for y un condicional if , se recorrerá la
información histórica dentro del archivo evaluando las condiciones dadas para poder dictaminar
si la posición es larga o corta, si se cumple alguna de las condiciones que se tiene para
cualquiera de las posibilidades, entonces se agregará “LARGO” o “CORTO” a la lista creada
para almacenar esta información, si no se cumple ninguna de los escenarios enviará a la lista un
posición vacía, simbolizado en Python como “ ”. Finalmente se retornará la lista en la que fue
almacenado esta información, y dos métodos de almacenamiento extraídos del archivo principal.
(Anexo G) La función está declarada en el programa de la siguiente manera:
def posicion_lc(lista_precios,lista_kinjun,lista_spana,lista_spanb):
return total_open, total_close, posicion
Es importante resaltar que las condiciones utilizadas en los ciclos del código de esta
función tienen como objetivo definir las posiciones de mercado teniendo como referencia la
estrategia de la investigación principal, es decir el rompimiento de la nube o Kumo respecto a la
Kinjun Sen.
Función cierre
Informar cuándo debe ser el cierre de las posiciones de acuerdo algunos comportamientos del
mercado y como consecuencia a las confirmaciones que necesita la estrategia de inversión, es

52
precisamente el objetivo por el cual se ha creado esta función, en el diagrama que se presenta a
continuación, se evidencia de manera gráfica el funcionamiento de la función.
Def cierre_lc.
archivocsv,
lista_kinjun,lista_spana,
lista_spanb,posicion.
O,SA,SB,K,
posicion SI CIERRE LARGO,
CIERRE CORTO
cierre [ ]
NO
""
Figura 12. Diagrama función cierre. Se evidencia el procedimiento de ejecución de la función
en mención de manera general y gráfica. Fuente: Creación propia (2017).
La lógica mediante la cual fue creada esta función es similar a la utilizada por
procedimientos que se han venido explicando, inicialmente necesitará de valores almacenados en
la base de datos, así como de “lista_kinjun”, “lista_spana”, “lista_spanb”, “posicion”; todos estos
son valores que han sido devueltos en funciones del programa anteriormente; posterior al
reconocimiento de esta información se comienza a hacer un ciclo de validación, para luego entrar
en los condicionales que permitirán concluir si debe haber cierre de posición, si se llega a
cumplir alguna de las condiciones propuestas se agregará “CIERRE CORTO” o “CIERRE

53
LARGO” según corresponda, si no se cumple ninguna entonces se agregará un mensaje vacío;
todos estos valores se irán almacenando a medida de la ejecución de la función en la lista
“cierre” y la cual será el retorno de esta función. (Anexo H). La sentencia dentro del método
principal y con la que se invoca esta función es:
cierre=cierre_lc(total_open,lista_kinjun,lista_spana,lista_spanb,posicion)
Función apertura.
Esta función tiene como objetivo principal concluir la apertura luego de la señal y confirmación
de mercado que requiere la estrategia y que se ha explicado en secciones anteriores. La manera
como se define la función es:
def apertura_lc(lista_tenkan, lista_kinjun, lista_spana, lista_spanb, posicion):
return apertura
Lo anterior simboliza que los requerimientos para la ejecución de está son los mismos
con los que se ha venido trabajando, el proceso de compilación de esta función se hace por
medio de un ciclo for que es el encargado de recorrer cada una de las listas que se encontraban
dentro de los requisitos, posteriormente pasa a los condicionales que con base a la información
en almacenada en listas, podrá deducir si es “APERTURA LARGO” o “APERTURA CORTO”,

54
en caso de no cumplir ninguna el valor devuelto será “ ” lo que significa vacío. Cada uno de los
retornos de esta función es almacenado en la lista “apertura” y al finalizar la compilación de los
ciclos será retornada al método principal. (Anexo I).
Función de resultados.
Para medir el desempeño que ha tenido la estrategia, se hace necesario la creación de una nueva
función. Mediante el recorrido de las listas “total_open”, “total_close”, “cierre”, “apertura”,
“posicion”, se hace el primer cálculo que es el resultado total de la estrategia, la manera mediante
la cual se llega a este resultado es restando en posiciones cortas el open de la apertura con el
open del cierre, y para posiciones largas el open del cierre y el open de la apertura.
Por otro lado, se realiza también el conteo de trades positivos y negativos tanto para
posiciones cortas y largas, la lógica empleada en este caso es contar los mayores o menores a
cero. En cuanto a la eficiencia, se debe finalmente sumar los trades positivos en ambas
posiciones y dividirlo sobre el total de trades realizados y multiplicarlo por 100 para tener el
resultado en forma de porcentaje, es este uno de los cálculos más importantes pues de acuerdo al
valor dado se puede dar o no la aprobación a la estrategia.

55
Posteriormente se calcula el trades máximo y el trades mínimo de los resultados largos y
cortos, para finalmente sacar un promedio total de trades. Estos son los valores calculados en
esta función y que son esenciales para realizar el análisis y de esta manera poder deducir si el
comportamiento que ha tenido la estrategia de inversión es satisfactorio. (Anexo J).
Función agregar y escribir archivo.csv
Después de realizar todos los cálculos y medir cualitativamente el comportamiento de la
estrategia de inversión, se debe agregar toda esa información almacenada en listas
independientes al archivo principal, para posteriormente generar desde el programa de Python un
nuevo archivo .csv que no solo contenga la base de datos histórica sino que además incluya el
cálculo de cada uno de los componente del indicador técnico Ichimoku Kinko Hyo, e
información relacionada con la posición, cierre y apertura. De manera independiente se generará
un archivo que guarda el resumen de cada configuración posible, con sus resultados arrojados.
(Anexo K)
Para desarrollar la función cuyo objetivo es escribir el archivo “.csv”, se tuvo como guía
el documento creado por Python para facilitar la comprensión del lenguaje. (Python Software
Foundation., 2017)
56
Resultados.
Tras un periodo de pruebas y arrojando resultados totalmente exitosos, se comparan los
resultados obtenidos en la investigación principal de referencia, con el fin de validar la ejecución
y cálculos dados por el anterior modelo Backtesting.
Es pertinente recordar los periodos históricos para cada marco de tiempo, en los cuales se
desarrolló el análisis de datos y se obtuvieron a los resultados:
 Activo: Euro/Dólar, Histórico: 30/11/2009-18/12/2013, Marco de Tiempo: 15 minutos.
Tabla 2:
Resultado nuevo modelo Backtesting.
Resultado General Nuevo Modelo Blacktesting.

Paramentros Trades (+) Trades (-) Trades (+) Trades (-) Total
Resultado Eficiencia Máx Min Promedio
(Tenkan,Kinjun,Adelantamiento, SpanB) Cortos Cortos Largos Largos Trades
EURUSD15 8 22 22 44 4154 220 478 274 479 1451 34.05% 886 -162 2.92
EURUSD15 9 26 26 52 2543 197 391 226 410 1224 34.56% 441 -190 2.11
EURUSD60 8 22 22 44 12154 164 233 162 255 814 40.05% 1445 -291 15.01
EURUSD60 9 26 26 52 10742 131 203 143 205 682 40.18% 1266 -270 15.75
EURSUSD240 8 22 22 44 16170 86 126 99 107 418 44.26% 979 -378 38.89
EURSUSD240 9 26 26 52 15024 77 108 82 100 367 43.32% 1108 -350 41.08
Nota: Se observa los valores arrojados por el nuevo modelo por cada configuración. Fuente:
Creación propia (2017).

57
En la tabla anterior, se muestran en la primera casilla el activo junto al marco de tiempo,
es decir, “EURUSD15”, en primer lugar se encuentra el nombre la paridad seguida de la
periodicidad, en este caso 15 minutos, de igual manera con los valores que se encuentran hacia
abajo por la misma columna de este, en segundo lugar se evidencia los parámetros por medio del
cual se realizó el análisis; con el fin de corroborar los resultados de la investigación principal de
referencia fueron utilizados los mismos para este estudio, seguido de resultado total, número de
trades positivos y negativos para posiciones cortas y largas, total trades, eficiencia, máximo y
mínimo, promedio de trades.
Cada uno de estos valores fue contrastado por los obtenidos en el modelo de Visual Basic
de la investigación principal de referencia, y es pertinente afirmar que todos los resultados son
iguales. Con el fin de cumplir a cabalidad lo propuesto, se expone a continuación los resultados
arrojados al actualizar la base de datos para la misma paridad en los mismos marcos de tiempo, y
con un nuevo periodo histórico:
 Marco de tiempo: 15 minutos, Periodo Histórico: 15/10/2014 – 27/06/2017.
 Marco de tiempo: 60 minutos, Periodo Histórico: 02/01/2007– 27/06/2017.

58
Tabla 3.
Resultados actualización de bases de datos.
Resultado General Nuevo Modelo Blacktesting. Actualización de cifras.

Paramentros Trades (+) Trades (-) Trades (+) Trades (-) Total
Resultado Eficiencia Máx Min Promedio
(Tenkan,Kinjun,Adelantamiento, SpanB) Cortos Cortos Largos Largos Trades
EURUSD15 8 22 22 44 4684 255 501 261 466 1483 34.79% 294 -118 3.13
EURUSD15 9 26 26 52 4397 226 390 226 412 1254 36.04% 443 -130 3.53
EURUSD60 8 22 22 44 16194 283 403 268 430 1384 39.81% 1442 -340 11.71
EURUSD60 9 26 26 52 13318 226 344 227 364 1161 39.02% 1266 -268 11.50
EURSUSD240 8 22 22 44 10041 61 108 72 88 329 40.43% 979 -378 30.54
EURSUSD240 9 26 26 52 9647 59 87 57 75 278 41.73% 1108 -350 35.01
Nota: Se puede evidenciar los nuevos resultados obtenidos con la actualización de bases de
datos. Fuente: Creación propia (2017)
Al realizar la actualización de las bases de datos se encuentra entonces que para el marco
de tiempo de 15 minutos, cuya base de datos es alrededor de dos años y medio, fue más eficiente
la configuración que trae por defecto el indicador que la propuesta en la investigación principal
de referencia, con un porcentaje de 36.04% frente al 34.79 % . Si se evalúa en términos de
rentabilidad, fue más rentable la configuración propuesta con un resultado de 4.684 frente a los
parámetros por defecto del indicador que tan solo registraron 4.397.
En cuanto a los resultados en el marco de 60 minutos y teniendo una base histórica de
diez años, la configuración propuesta fue más eficiente con un 39.81% frente al valor de los
59
parámetros por defecto del indicador cuyo porcentaje fue de tan solo 39.02%, a su vez la primera
configuración enunciada, presentó un resultado superior en comparación con la segunda
mencionada, dejando así un resultado de 16.194 y 13.318 respectivamente.
Por otro lado al analizar el marco de tiempo de 240 minutos, la mejor eficiencia se
encuentra con la configuración por defecto del indicador técnico Ichimoku Kinko Hyo con un
porcentaje de 41.73% frente a la propuesta que es de tan solo 40.43%, aunque esta última arrojó
un mejor resultado en comparación con la otra, dejando así un valor de 10.041 y 9647
respectivamente.
En términos generales la estrategia de inversión propuesta cuyo énfasis está en el
rompimiento del Kinjun Sen respecto a la nube, fue aumentando su eficiencia al incrementarse el
marco de tiempo, el mejor porcentaje en relación a esto encontrado estuvo en la periodicidad de
240 minutos, si bien el mejor resultado se ubicó en el marco de tiempo 60 minutos, al evaluar la
estrategia no es confiable del todo este valor pues pudo estar concentrado principalmente por una
sola operación cuando hubo tendencia en el mercado.

60
Finalmente se deja al descubierto que toda estrategia de inversión es funcional bajo
ciertas condiciones tanto de tiempo, paridad y en los parámetros de configuración, como
consecuencia, existirán ciclos de mercado que no se ajustan satisfactoriamente a algunas
estrategias o planes de trabajo pero que en el pasado si lo hicieron y posiblemente en el futuro se
repita, por tal motivo la búsqueda de nuevos comportamientos dentro del mercado que puedan
verse transformadas en oportunidades de inversión debe ser un trabajo constante.
De esta manera, se ha cumplido el primer objetivo planteado en la actual investigación y
el nuevo modelo Backtesting no solo validó los datos en un tiempo inferior obtenidos bajo otro
lenguaje de programación (VBA), sino que además permite actualizar las bases de datos, como
consecuencia es posible tener al día las cifras que miden el desempeño de esa estrategia en cada
activo y cada marco de tiempo.

61
CAPITULO 2
Optimización de estrategias de inversión.
Evidenciando los resultados positivos que se obtuvieron en la estrategia realizada en la
investigación principal de referencia, bajo la configuración optima sugerida, es pertinente seguir
evaluando escenarios y comportamientos del indicador Ichimoku Kinko Hyo que no fueron
posibles abordar en esa investigación, pero que sin duda podría simbolizar un aumento en el
desempeño de la estrategia. En este capítulo se pretende realizar la optimización de las
estrategias de inversión para la paridad EUR/USD y analizar los resultados obtenidos en cada
una.
Propuesta inicial nuevas estrategias de inversión.
Se planeó inicialmente la evaluación de nuevas estrategias relacionadas con el cruce de la Kinjun
Sen y Tenkan Sen, respecto al estado de la Kumo (sobre, en medio y debajo), pero en el
desarrollo de estas, se evidencian nuevos hechos relacionados y como consecuencia se establece
el nuevo filtro relacionado con la distancia del precio y la nube, con el fin de contemplar nuevas
oportunidades de mercado.
Se proponen cinco entradas diferentes, todas relacionadas con el estado del Kumo y seis
cierres distintos, para combinarlos posteriormente y hacer de cada una de estas una nueva
estrategia, para finalmente analizar el desempeño obtenido en cada caso de estudio.

62
Aperturas.
A continuación se describe cada una de las propuestas de apertura y se complementa la
explicación con un ejemplo gráfico.
Cruce Tenkan Sen y Kinjun Sen sobre la nube.
Para una apertura de posición larga el corte de la Tenkan Sen con respecto a la Kinjun Sen se
presenta de forma ascendente, y en la parte superior del Kumo. Caso contrario ocurrirá cuando la
posición sea corta, pues el cruce de las dos líneas principales deberá ser de manera descendente
como se muestra a continuación.

63
Figura 13. Primera propuesta de apertura larga: Se evidencia el cruce de las líneas sobre la
nube, resaltado con el círculo rojo para apertura posición larga y posición corta. Fuente:
Metatrader (2017).
Cruce Tenkan Sen y Kinjun Sen en medio de la nube.
El corte de la Tenkan Sen con la línea Kinjun Sen con dirección ascendente indica una posición
larga, y este debe ser en medio del Kumo; la apertura de la posición corta se dará cuando la
dirección del cruce sea descendente.
Figura 14 Segunda propuesta de apertura larga: Se evidencia el cruce de las líneas en medio
de la nube resaltado con el círculo rojo para apertura posición larga y posición corta. Fuente:
Metatrader (2017).
64
Cruce Tenkan Sen y Kinjun Sen debajo de la nube.
Para la apertura de una posición larga, el cruce de la línea Tenkan Sen y la línea Kinjun Sen debe
ser con dirección arriba, este debe realizarse en la parte inferior de la nube; para una posición
corte, el cruce de estas dos líneas (Tenkan Sen y Kinjun Sen) se debe realizar con dirección
abajo.
Figura 15. Tercera propuesta de apertura larga: Se evidencia el cruce de las líneas debajo del
Kumo, resaltado con el círculo rojo para apertura posición larga y posición corta. Fuente:
Metatrader (2017).
Cruce Tenkan Sen y Kinjun Sen y el precio (open) mayor a 50 pips con respecto a la
nube.
Para la apertura de una posición bajo este propuesta es necesario cumplir dos requisitos, el
primero hace referencia al cruce de la Tenkan Sen respecto a la Kinjun Sen de forma ascendente
65
y en la parte inferior del Kumo, el segundo, debe existir una distancia mayor a 50 pips entre el
precio (Open) y la nube, para marcar apertura larga. El cruce entre estas dos líneas (Tenkan Sen
y Kinjun Sen) se debe realizar de forma descendente para la apertura posición corta, y en la parte
superior de la nube, con la misma distancia entre el precio (Open) y el Kumo.
LARGO
CORTO
Figura 16. Cuarta propuesta de apertura larga: Se evidencia el cruce de las líneas debajo del
Kumo, resaltado con el círculo rojo para apertura posición larga con una distancia mayor a 50
pips; para la apertura de la posición corta, se observa el cruce de las líneas de forma descendente
por encima de la nube. Fuente: Metatrader (2017).
Cruce Tenkan Sen y Kinjun Sen y el precio (open) menor a 50 pips con respecto a la
nube.
66
El planteamiento de esta apertura larga consiste en el cruce sobre la nube de la Tenkan Sen
respecto a la Kinjun Sen con dirección ascendente, además, una distancia que no sea superior a
50 pips entre en precio (open) y el Kumo. Para una apertura corta, es necesario que el cruce de
las líneas (Tenkan Sen y Kinjun Sen) se realice debajo de la nube.
LARGO
CORTO
Figura 17. Quinta propuesta de apertura larga: Se evidencia el cruce de las líneas sobre la
nube, se simboliza con el círculo rojo, también es posible observar que la distancia del precio
(open) y el Kumo es inferior a 50 pips, dando con esto aviso de una apertura larga. El cruce de
las líneas (Tenkan Sen y Kinjun Sen) por debajo de la nube, señala apertura de una posición
corta. Fuente: Metatrader (2017).
Cierres.
67
Luego de confirmar cualquier apertura de las descritas la sección anterior, se proponen seis
cierres diferentes, para consolidar varias estrategias de inversión, con el fin de evaluar nuevos
comportamientos de mercado, que puedan traer consigo aumento en el desempeño de las
estrategias. Enseguida se explica cada uno con ayuda gráfica.
Cruce de la Tenkan Sen y Kinjun Sen en cualquier lugar.
Si la apertura fue larga, entonces el cruce de la Tenkan Sen y la Kinjun Sen debe realizarse de
manera descendente sin importar el lugar en donde se produzca en relación con el Kumo.Para el
cierre de una posición corta, es necesario que el cruce de la Tenkan Sen este en dirección
ascendente en relación con la Kinjun Sen.
Figura 18. Primer propuesta de cierre largo. Se evidencia el corte de la Tenkan Sen hacia
abajo respecto a la Kinjun Sen, señalando cierre de posición larga. Además, el cruce hacia arriba
de la Tenkan Sen con la Kinjun Sen, señalando cierre corto Fuente: Metatrader (2017)
68
Ingreso a la nube de la Kinjun Sen y precio (Close).
Tanto para posiciones largas o cortas este cierre será igual en ambos escenarios, el cual consiste
en cerrar la posición abierta, cuando ingrese a la nube el precio (Close) y la Kinjun Sen.
Figura 19. Segunda propuesta de cierre corto o largo. Se observa que el precio ingresa
primero a la nube, para después ingresar la Kinjun Sen y anunciar el cierre de posición. Fuente:
Metatrader (2017).
Precio (Close) debajo de la nube y Kinjun Sen en medio de la nube.
Cuando el precio Close se ubique en la parte inferior del Kumo y a su vez la Kinjun Sen se
ubique en medio de la nube, marcará cierre para cualquier posición, ya sea corta o larga.
69
Figura 20. Tercera propuesta de cierre cortó o largo. Se observa que el precio ingresa
primero a la nube, para después ingresar la Kinjun Sen y anunciar el cierre de posición. Fuente:
Metatrader (2017).
Kinjun Sen encima de la nube y el precio (Close) debajo de la nube.
En el instante donde la Kinjun Sen se ubique encima del Kumo y a su vez el precio (Close) se
encuentra debajo de la nube, será entonces el momento de cerrar la posición abierta, ya sea corta
o larga.
70
Figura 21. Cuarta propuesta de cierre corto o largo. Se puede evidenciar la ubicación del
precio Close debajo de la nube y la línea Kinjun Sen sobre la nube, indicando así el cierre corto o
largo, según la posición abierta. Fuente: Metatrader (2017).
Kinjun Sen debajo de la nube y precio (Close) inferior a Kinjun Sen.
El cierre bajo esta propuesta, se hará cuando el precio (Close) se ubique por debajo de la línea
Kinjun y está a su vez se encuentra en la parte inferior de la nube.

71
Figura 22. Quinta propuesta de cierre corto o largo. Se puede evidenciar la ubicación de la
Kinjun Sen debajo de la nube y el precio (Close) a la vez debajo de la Kinjun Sen representada
en la gráfica como la línea roja, afirmando con esto el cierre de la posición abierta. Fuente:
Metatrader (2017).
Kinjun debajo de la nube y el precio (Close) en medio de estas dos.
La línea Kinjun Sen debe situarse en la parte inferior de la Kumo, y el precio (Close) debe
ubicarse en medio de estas estas dos, de esta manera se afirma un cierre para cualquier posición
abierta.
72
Figura 23. Sexta propuesta de cierre largo o corto. Se observa como la Kinjun Sen está
situada debajo de la nube y que además el precio (Close) está en medio de la Kumo y la Kinjun.
Fuente: Metatrader (2017).
Luego de haber explicado previamente las cinco opciones de apertura y las seis de cierre, se
plantea realiza la combinación entre ellas para obtener un total de treinta nuevas estrategias, que
serán puestas a prueba para poder encontrar las más eficientes en el mercado.
Resultados de las estrategias planteadas.
Cada una de las estrategias estudiada con las siguientes bases de:
 Marco de tiempo: 15 minutos, Periodo Histórico: 15/10/2014 – 27/06/2017.

73
Los rangos utilizados durante este estudio para cada uno de los componentes del indicador
técnico Ichimoku Kinko Hyo fueron: Tenkan Sen desde 8 hasta 9, Kinjun Sen inicia en 23 y
finaliza en 30, Senkou Span A comienza en 3 termina en 11 y por último el Senkou Span B se
encuentra desde 43 hasta 53.
El número de combinaciones posibles entre los intervalos definidos anteriormente es de
1440, cada una de estas fue ejecutada en cada base de datos y analizados los resultados
provenientes de este proceso, para así poder establecer la mejor configuración de cada parámetro
en las estrategias establecida previamente. Para todos los casos la esperanza matemática fue
positiva. A continuación se expondrán los resultados con base a lo aclarado anteriormente.
Estrategia 1. Apertura: Cruce sobre la nube entra la Tenkan Sen y Kinjun Sen. Cierre:
Cruce entra la Tenkan Sen y Kinjun Sen en cualquier lugar.
Con un resultado de 5007.4 pips y una eficiencia de 40.19%, el marco de tiempo que mejor se
desempeñó en esta estrategia fue 60 minutos, con una configuración de: 9 Tenkan Sen, 23
Kinjun Sen, 10 Senkou Span A y 52 Senkou Span B.

74
El marco de tiempo en el cual se pudo evidenciar el mejor desempeño fue 60 minutos, con la
configuración para cada componente del indicador técnico Ichimoku Kinko Hyo así, Tenkan Sen
9, Kinjun Sen 26, Senkou Span A 11 y Senkou Span B 43; con un resultados de 6049.7 pips y
una eficiencia de 49.43 %.
Precio (Close) debajo de la nube y Kinjun Sen en medio de la nube.
La configuración óptima para esta estrategia es, para la Tenkan Sen un parámetro de 8, Kinjun
Sen 29, Adelantamiento 11 y Senkou Span B 52, en el marco de tiempo de 60 minutos, dando
con esta un resultado de 4.833 pips, junto a una eficiencia del 52.74%, lo que quiere decir que de
la totalidad de operaciones abiertas bajo esta estrategia fueron positivas o generaron rentabilidad
este porcentaje.

75
El resultado obtenido en el mejor escenario bajo esta estrategia fue de 7.541 pips con una
eficiencia de 49.51%, baja el marco de tiempo de 60 minutos; la configuración para este
desempeño fue de 8,25,7,47 para la Tenkan Sen, Kinjun Sen, Adelantamiento y Senkou Span B
sucesivamente.
Kinjun Sen debajo de la nube y el precio (Close) inferior a Kinjun Sen.
Con una eficiencia del 53,92% y un resultado de 5.091 pips, obtenido por el marco de tiempo de
60 minutos, y con unos parámetros de 8 para la Tenkan Sen, 25 Kinjun Sen, 9 Adelantamiento y
52 Senkou Span B, se observó el mejor desempeño para esta estrategia.
Kinjun Sen debajo de la nube y el precio (Close) en medio de estas dos.
En el marco de tiempo de 240 minutos fue posible observar el mejor desempeño de esta
estrategia con una configuración de parámetros del indicador técnico Ichimoku Kinko Hyo de 9
para la Tenkan Sen, 27 para la Kinjun Sen, 4 de adelantamiento de la nube y 43 para Senkou
Span B, como consecuencia un resultado de 6.631 pips con una eficiencia del 54,83%.
76
Estrategia 7. Apertura: Cruce Tenkan Sen y Kinjun Sen en medio de la nube. Cierre:
Cruce entra la Tenkan Sen y Kinjun Sen en cualquier lugar.
Con un eficiencia del 41.86 % y un resultado de 9.536 pips, en el marco de tiempo de 60
minutos, se encontró el escenario óptimo para esta estrategia, con un configuración para la
Tenkan Sen de 8, Kinjun Sen 28, Senkou Span A 11 y Senkou Span B 52.
En el marco de tiempo de 60 minutos se evidencio el entorno para el desempeño óptimo de esta
estrategia, el cual dejo como resultado 10.450 pips junto a una eficiencia de 50.27%, los
paramentos utilizados para esto fueron: 9, 28, 10, 48 para la Tenkan Sen, Kinjun Sen, Senkou
Span A y Senkou Span B, sucesivamente.
Preció (Close) debajo de la nube y Kinjun Sen en medio de la nube.
La configuración de parámetros para la Tenkan Sen de 8, Kinjun Sen de 28, Senkou Span A de
11 y Senkou Span B 51, se presentó el mejor escenario para esta estrategia, dejando como
resultado 6.617 pips con una eficiencia de 52.08%

77
El resultado para esta estrategia en el escenario óptimo fue de 11.282 pips junto a una eficiencia
de 54.4%, en el marco de tiempo de 60 minutos, las configuraciones para cada parámetro del
indicador técnico fueron: Tenkan Sen 8, Kinjun Sen 28, Adelantamiento 11, Senkou Span B 50.
Con una configuración para la Tenkan Sen 8, Kinjun Sen 28, Senkou Span A 10 y Senkou Span
B 52, con un marco de tiempo de 60 minutos, se evidencio un entorno óptimo para esta estrategia
de inversión, con un resultado de 5.333 pips y una eficiencia de 51,72%.
Con un resultado de 11.070 pips junto a una eficiencia de 49,30% , en el marco de tiempo de 60
minutos, y con una configuración de parámetros para los componentes del indicador técnico
Ichimoku Kinko Hyo de 9,28,10,52 para la Tenkan Sen, Kinjun Sen, Senkou Span A y Senkou
Span B respectivamente.
78
Estrategia 13. Apertura: Cruce Tenkan Sen y Kinjun Sen debajo de la nube.
Cierre: Cruce entra la Tenkan Sen y Kinjun Sen en cualquier lugar.
La configuración optima de las parámetros Tenkan Sen, Kinjun Sen, Senkou Span A y Senkou
Span B, y con el marco de tiempo de 240 minutos, fue el escenario óptimo para esta estrategia de
inversión cuyo resultado obtenido fue de 5.400 pips con una eficiencia de 42,02%.
Estrategia 14. Apertura: Cruce Tenkan Sen y Kinjun Sen debajo de la nube.
Cierre: Ingreso a la nube de la Kinjun Sen y precio (Close).
La eficiencia óptima para esta estrategia de inversión fue de 50.86 %, con un resultado de 5.890
pips en un marco de tiempo de 60 minutos, con una configuración de parámetros de 8 para la
Tenkan Sen, 30 Kinjun Sen, 11 Senkou Span A, 46 Senkou Span B.
Estrategia 15. Apertura: Cruce Tenkan Sen y Kinjun Sen debajo de la nube. Cierre:
Precio (Close) debajo de la nube y Kinjun Sen en medio de la nube
La configuración bajo la cual se dio el mejor desempeño de esta estrategia de inversión fue,
Tenkan Sen 8, Kinjun Sen 30, Senkou Span A 5 y Senkou Span B 50, para obtener de esta
manera un resultado de 5.750 pips y una eficiencia de 55.42%.

79
En el marco de tiempo de 240 minutos, se evidenció el mejor desempeño de esta estrategia de
inversión con un resultado de 5.568 pips frente a la eficiencia de 51.37%, con las siguiente
configuración: Tenkan Sen 8, Kinjun Sen 30, Adelantamiento de la nube 8 y Senkou Span B 45.
El resultado que dejo el escenario con el mejor desempeño de esta estrategia es 6.191 pips con
una eficiencia de 54.31% en el marco de tiempo de 240 minutos, con la configuración de la
Tenkan Sen, Kinjun Sen, Senkou Span A, Senkou Span B de 8,29,7,52 respectivamente.

80
El mejor desempeño de esta estrategia es bajo el marco de tiempo de 240 minutos, con una
configuración de Tenkan Sen 8, Kinjun Sen 26, Adelantamiento 8 y Senkou Span B 44, dejando
como resultado esto 7.572 pips y una eficiencia de 54.92%
Estrategia 19. Apertura: Cruce Tenkan Sen y Kinjun Sen y el precio (open) mayor a 50
pips con respecto a la nube. Cierre: Cruce entra la Tenkan Sen y Kinjun Sen en cualquier lugar.
En el marco de tiempo de 240 minutos y con una configuración de 8, 26, 8,44 para la Tenkan
Sen, Kinjun Sen, Senkou Span A y Senkou Span B sucesivamente, se observó el mejor
desempeño de esta estrategia, obtenido como resultado 1.617 pips con una eficiencia del 77.77%.
pips con respecto a la nube. Cierre: Ingreso a la nube de la Kinjun Sen y precio (Close).
La eficiencia de 83.87% y el resultado de 2.003 pips, reflejó el desempeño optimo obtenido en
el marco de tiempo 60 minutos, con el parámetro para la Tenkan Sen de 8, Kinjun Sen 26,
Adelantamiento de la nube 10, Senkou Span B 43, en esta estrategia de inversión.
pips con respecto a la nube. Cierre: Precio (Close) debajo de la nube y Kinjun Sen en medio de
la nube.
81
En el marco de tiempo de 240 minutos, se evidencia el escenario óptimo para el mejor
desempeño de esta estrategia, pues se obtuvo un resultado de 1.410 pips con una eficiencia del
70%, tras una configuración de parámetros del indicador de 9 Tenkan Sen, 23 Kinjun Sen, 10
Adelantamiento de la nube, 52 para el Senkou Span B.
pips con respecto a la nube. Cierre: Kinjun Sen encima de la nube y el precio (Close) debajo de
la nube.
Con una eficiencia del 82.35% y con un resultado de 2.907 pips en el marco de tiempo de 240
minutos fue registrado el mejor desempeño de esta estrategia, con la siguiente configuración:
Tenkan Sen 8, Kinjun Sen24, Adelantamiento de la nube 11 y Senkou Span B 48.
pips con respecto a la nube. Cierre: Kinjun Sen debajo de la nube y el precio (Close) inferior a
Kinjun Sen.
La configuración de parámetros del indicador técnico Ichimoku Kinko Hyo con la cual fue
posible obtener el mejor desempeño de esta estrategia es, para la línea Tenkan Sen 9, Kinjun Sen
82
23, Senkou Span A 9 y Senkou Span B 50, tras un resultado de 2.870 pips con una eficiencia del
84%.
pips con respecto a la nube. Cierre: Kinjun Sen debajo de la nube y el precio (Close) en medio
de estas dos.
El mejor desempeño de esta estrategia fue evidenciado al obtener una eficiencia del 84.61%, y
un resultado de 3.664 pips, con un marco de tiempo de 240 minutos, tras una configuración del
indicador técnico Ichimoku Kinko Hyo de 9 para la Tenkan Sen, 23 Kinjun Sen, 10 Senkou Span
A y 47 Senkou Span B.
Estrategia 25. Apertura: Cruce Tenkan Sen y Kinjun Sen y el precio (open) menor a 50
pips con respecto a la nube. Cierre: Cruce entra la Tenkan Sen y Kinjun Sen en cualquier lugar.
Con un marco de tiempo de 60 minutos, y una configuración de parámetros de 8 para la Tenkan
Sen, 28 Kinjun Sen, 11 para el adelantamiento de la nube y 44 de Senkou Span B, el resultado
obtenido fue de 8.174 pips con una eficiencia de 42.96
pips con respecto a la nube. Cierre: Ingreso a la nube de la Kinjun Sen y precio (Close).
83
El escenario optimo en esta estrategia fue encontrando con la siguiente configuración de los
parámetros del indicador técnico, 8,24,3,43 para la Tenkan Sen, Kinjun Sen, Senkou Span A y
Senkou Span B respectivamente, con un resultado de 5.626 pips y una eficiencia de 57.02%.
pips con respecto a la nube. Cierre: Precio (Close) debajo de la nube y Kinjun Sen en medio de
la nube.
Con una eficiencia del 60.19% y con un resultado de 4.334 pips, en el marco de tiempo de 240
minutos y con la configuración de la Tenkan Sen de 8, Kinjun Sen 26, Senkou Span A 3 y
Senkou Span B 43, se evidencia el escenario óptimo para esta estrategia.
pips con respecto a la nube. Cierre: Kinjun Sen encima de la nube y el precio (Close) debajo de
la nube.
El mejor escenario en el cual el desempeño de esta estrategia fue optimo, un marco de tiempo de
240 minutos, con un resultado de 6.645 pips y una eficiencia de 66.07%, con una configuración
de 8 para la Tenkan Sen, 30 Kinjun Sen, 8 adelantamiento de la nube y 51 Senkou Span B.

84
pips con respecto a la nube. Cierre: Kinjun Sen debajo de la nube y el precio (Close) inferior a
Kinjun Sen.
El resultado para esta estrategia en el escenario optimo fue de 4.652 pips con una eficiencia de
65.13%,en un marco de tiempo de 240 minutos, tras una configuración de la Tenkan Sen de 8, 29
para la Kinjun Sen, 3 para el Senkou Span A y 43 para la Senkou Span B.
pips con respecto a la nube. Cierre: Kinjun Sen debajo de la nube y el precio (Close) en medio
de estas dos.
Tras una configuración de parámetros de 8, 23, 4, 45 para la Tenkan Sen, Kinjun Sen, Senkou
Span A y Senkou Span B respectivamente, se evidenció el mejor desempeño para esta estrategia
con un resultado de 7.000 pips y una eficiencia de 61%, en un marco de tiempo de 240 minutos.
Resultados finales.
De acuerdo al planteamiento de estrategias realizado en este trabajo, cuyo fin era descubrir
nuevas escenarios idóneos para invertir y luego de exponer los resultados, es importante destacar
que debido al modelo Backtesting creado en el lenguaje de programación Python, fue posible
85
evaluar en un tiempo corto, el rango de configuraciones establecidas para el indicador técnico
Ichimoku Kinko Hyo que permitiría a la vez descubrir el mejor desempeño para cada momento
estudiado.
El desempeño medido por la rentabilidad, eficiencia y esperanza matemática va
aumentando a medida que incrementa el marco de tiempo, es decir para este caso puntual, las
bases de datos de 240 minutos tuvieron en 16 estrategias de 30 posibles el mejor desempeño,
seguido de 60 minutos con el restante, para los rangos de datos previamente definidos.
Se pudo obtener eficiencias para todas las estrategias superiores al 40%, y la máxima
encontrada fue de 84.61% con la estrategia número 24 (Apertura: Cruce Tenkan Sen y Kinjun
Sen y el precio (Open) mayor a 50 pips con respecto a la nube. Cierre: Kinjun Sen debajo de la
nube y el precio (Close) en medio de estas dos.), cuya configuración óptima para el indicador
técnico era: Tenkan Sen 9, Kinjun Sen 23, Adelantamiento de la nube 10, Senkou Span B 47,
estas cifras reflejan que si bien algunas estrategias tuvieron un mejor desempeño frente a otras,
todas arrojaron cifras de resultados, esperanza matemática y eficiencia positivas.

86
En cuanto a la rentabilidad, se obtuvo un punto máximo de 11.282 pips, con la estrategia número
10 (Apertura: Cruce Tenkan Sen y Kinjun Sen en medio de la nube. Cierre: Kinjun Sen encima
de la nube y el precio (Close) debajo de la nube.), cuya configuración óptima encontrada para
cada componente del indicador técnico Ichimoku Kinko Hyo fue: Tenkan Sen 8, Kinjun Sen 28,
Adelantamiento de la nube 11 y Senkou Span B 50.
Teniendo como filtro de apertura el estado de la nube respecto al cruce de la Kinjun Sen y
Tenkan Sen, y la distancia que hay entre la nube respecto al cruce es posible afirmar basado en
los resultados expuestos anteriormente que aumento el desempeño en comparación con la
estrategias propuesta en la investigación principal de referencia.
Si bien los resultados obtenidos fueron positivos, es necesario seguir con el proceso de
optimización, para poder definir un valor para los Stop Loss, Take Profit, Cantidad de inversión
(Lotes), este proceso es posible realizar de manera oportuna con la metodología ARISTOS.
87
Activo Funcional
En vista de los resultados positivos y los alcances que se han visto del nuevo modelo
Backtesting, se propone dos nuevos algoritmos, el primero permite la descarga online de un
histórico de precios de los activos deseados por el usuario y su posterior análisis por el modelo
Backtesting; el segundo dependerá de la cantidad de bases de datos almacenadas, cada una en un
archivo “.csv” otorgadas por el usuario, para luego continuar con el procedimiento acostumbrado
que da como resultado el cálculo del indicador técnico Ichimoku Kinko Hyo.
El objetivo principal de cada una de estas nuevas propuestas será analizar los resultados
de cada activo de acuerdo a la estrategia de inversión y rango de parámetros de configuración
suministrados, para cada uno el algoritmo elaborará un documento con formato “.csv” en el que
se encontraran almacenados los resultados obtenidos (resultado total, numero de trades positivos
y negativos para posiciones cortas y largas, total trades, eficiencia, máximo y mínimo, promedio
de trades), de acuerdo a la estrategia programada y por cada configuración posible, finalmente
concluirá arrojando el activo más eficiente dentro de los indicados por el usuario junto a su
configuración, y generar un nuevo archivo “.csv” con los cálculos del indicador técnico
Ichimoku Kinko Hyo de este, así como también aperturas y cierres.

88
Descarga de Base Histórica de activos online
La información será descargada automáticamente por el algoritmo del portal web Google
Finance, y debido a los alcances de esta página en cuanto a precios históricos solo podrán ser
descargadas acciones.
El usuario debe indicar al programa los activos a analizar, para esto se ha creado una lista,
en la cual se debe escribir el nemotécnico utilizado en las bolsas y con el cual se encuentra en
páginas web que brindan información fundamental y técnica de cada uno de estos, por ejemplo:
GOOGLE FINANCE.
Esta lista encabeza el método principal y debe contar como mínimo con el nombre de un
activo que se desea analizar, cada nemotécnico de ir en medio de comillas (“ ”) y separado uno
del otro por comas (,) a continuación un ejemplo de cómo registrar los valores en este medio de
almacenamiento.
ACCI =["GOOG","AAPL","MSFT"]
89
En la sentencia anterior se quiso dar a entender cómo se debía rellenar la lista en caso de
que los activos a analizar fueran estas tres acciones, empezando por GOOGLE, seguido de
APPLE, y finalizando con MICROSOFT.
Posteriormente, se encuentran dos variables, la primera es “comienzo”, donde debe
definirse la fecha desde la cual se debe descargar la información, el formato de esta variable es:
año, mes, día; para los meses y días que solo tengan un digito, no se debe anteponer el número
cero, pues esto podría generar un error dentro del código; es decir, si se desea descargar
información desde el 01/08/2016 en Python debe ir 2016, 8,1. A continuación, se encuentra la
variable “fin”, creada para definir el límite del descargue de la información, por defecto hasta el
día que se ejecute el programa.
Consecutivamente, se encuentra un ciclo repetitivo “for” cuya función es descargar cada
activo exigido por el usuario, y generar con esta información un nuevo archivo “.csv” en donde
solo se encontrará los datos descargados. (Anexo L)
El código para realizar esta función fue tomado de portal web (David, 2017) , si bien el
video es explícito en que el medio por el cual se realiza la descarga de información es Yahoo
90
Finance, no es posible realizarlo por este método como consecuencia a que la URL a la cual se
direccionan los paquetes que por defecto trae instalado Python, se encuentra fuera de servicio.
Como consecuencia, se decide cambiar la librería para poder hacer efectivo el proceso, en
decir el cambio que se debe hacer es cambiar “yahoo” por “google” (The PyData Development
Team, 2015).
El usuario debe tener en cuenta antes de ejecutar el programa, definir los parámetros de
cada uno de los componentes del indicador técnico Ichimoku Kinko Hyo, a partir de este
momento la ejecución del modelo Backtesting es como ya se ha explicado en secciones
anteriores.
Base Histórica Adjunta.
En esta nueva propuesta, el usuario debe suministrar al programa el nombre de los archivos en
los cuales se encuentra la información que se desee procesar, para esto se ha creado una lista
llamada “ACTIVO”, allí solo debe estar el nombre del archivo(s), sin extensión alguna, es decir
sin “.csv”, cada uno en medio de comillas (“ ”) y separado por comas (,), como por ejemplo:
91
ACTIVO =["EURUSD15","EURUSD60","EURUSD240"]
La información debe estar guardada en un archivo de formato (“.csv”), y con el orden
expresado en secciones anterior, no cumplir con este orden puede causar que depure el programa.
De igual manera el usuario debe asignar el rango de datos para cada componente del indicador
técnico Ichimoku Kinko Hyo, para así cumplir a cabalidad con los requisitos del programa.
La salida que se obtendrá para cualquiera de las propuestas mencionadas anteriormente es
la misma, es decir la conclusión del activo que mejor se adecuo a la estrategia programada, en
términos de eficiencia, para este se generará un archivo “.csv” con la información acerca del
cálculo del indicador técnico bajo los parámetros óptimos. Adicionalmente, por cada activo
suministrado, el programa almacenará los resultados obtenidos en cada configuración posible un
documento para el análisis individual.
El uso oportuno de estos programas puede aportar sin duda, rapidez en los tiempos de
análisis y estudio de una estrategia de inversión, pues es una herramienta que proporciona
facilidad y agilidad en la ejecución de los procesos.

92
CAPITULO 3.
Interconexión plataforma de negociación Trader Workstation y lenguaje de programación
Python.
En este capítulo, se pretende explicar el método mediante el cual se logra realizar la
interconexión verídica entre el lenguaje de programación Python y la plataforma de negociación
Trader Workstation, para obtener información histórica, tiempo real y realizar envió de órdenes
de mercado; las razones por las cuales se propone este tipo de conexión es principalmente,
mitigar el riesgo operativo proveniente de los operadores del mercado, asociados a la posición
que se pueda tomar (corta o larga), la cantidad (Lotes) del activo de inversión, el establecimiento
de niveles de cierres para las operaciones abierta, entre otros, que sin duda pueden desencadenar
en pérdidas económicas; adicionalmente poder combatir la ejecución lenta del calce y envió de
las operaciones al ejecutarlas de manera manual, y finalmente para no revelar a la principal
contraparte del inversionista (Broker) la identidad de las estrategias de inversión.
Métodos de conexión.
Para poder establecer la conexión, fue necesario remitirse al libro “Succesfull Algorithmic
Trading” (Halls Moore, 2015), el cual aportó de manera específica los conceptos claves para
poder entender la metodología del enlace entre la plataforma de negociación Trader Workstation
y el lenguaje de programación Python, si bien toda la explicación fue clara al momento de
ejecutar el código que este propone, los resultados no fueron satisfactorios, se desconoce el
motivo, y como consecuencia se acudió a páginas de internet y foros virtuales de programadores
como lo es Stackoverflow , Github, entre otros.

93
Se encuentra entonces un sitio web cuya propuesta es un código de conexión para envió
de ordenes desde Python al API de Interactive Brokers (QuantStart, s.f), el cual al ejecutarlo fue
satisfactorio el resultado y se pretende explicarlo a continuación.
El código comienza con la definición de dos funciones, cuyo objetivo es comunicar los
errores que se presenten al intentar enviar cualquier solicitud al servidor “error_handler” y la otra
permite recibir la respuesta por parte de este “reply_handler”, esta última retorna un mensaje
con el tipo de error y su significado.
Posterior a esto se crea otra función nombrada “create_contract”, en la cual se definir el
activo en el cual se desea invertir, la clasificación que tiene este dentro del mercado (divisas,
acciones, bonos, commodities, etc.), el enrutador por el cual va ir dirigida la orden, esto cambia
dependiendo el tipo de activo en el que se desea invertir, y finalmente la moneda con la que se
realizará la operación.
Luego de esto se encuentra la función “create_order”, aquí se debe especificar el tipo de
orden si es a mercado entonces “MKT”, al límite de mercado “LMT”, stop limit “STP LMT”,
94
trading stop “TRAIL” entre otras, estas opciones fueron encontradas en la guía que proporciona
Interactive Brokers (Interactive Brokers, s.f), también se define dentro de esta función la
cantidad que se desea adquirir y se aclara además si es la posición de compra “BUY” o de venta
“SELL”.
Finalmente se encuentra el método principal en donde es invocada cada uno de las
funciones que se mencionaron anteriormente y donde se completa la información necesaria para
la ejecución adecuada.
El método principal inicia con la sentencia que permite crear la conexión directa con el
entorno de negociación, esto se hace invocando una librería que trae Python, además se debe
diligenciar el portal al cual está conectado la plataforma y el clienteId ambos suministrados por
la API, además para poder ejecutar el código satisfactoriamente es necesario activar algunas
funciones dentro de los ajustes de la configuración global de la plataforma, la ruta que debe
seguir debe ser: Archivo, Configuración Global, API, Ajustes.

95
Figura 24. Configuración API. Se puede observar las configuraciones previas necesarias para
poder ejecutar el código Python. Fuente: Trader Workstation (2017).
Lo encerrado en la gráfica anterior de color amarillo son las funciones que se deben
activar para el funcionamiento adecuado del código, lo color amarillo es el puerto al cual está
conectada la plataforma y que será necesario suministrar al código para hacer efectiva la
conexión, por último lo enmarcado de color verde es el número que debe asignar el usuario para
su identificación, en este caso se asignó el 888.

96
Posterior a la creación, se invoca la función para hacer efectiva la conexión, luego se
llama a las funciones creadas para la comunicación de errores y respuestas con el servidor,
adicionalmente aparece una variable “order_id”, esta debe aumentar en una unidad cada vez que
se ejecute una operación, seguirá entonces la sentencia en la cual se debe especificar los
requisitos de la función “create_contract”, para luego indicar el tipo de orden, cantidad y moneda
en la que se desea realizar la operación, finalmente se envía la orden por medio de la función
“placeOrder” que trae por defecto la librera en Python y luego se procede a desconectarse.
(Anexo M).
Es importante mencionar que la versión Python que se debe usar para la ejecución
satisfactoria de este código es la 2.7, puesto que las librerías utilizadas vienen en esa versión, no
ejecutarla en esta desencadenaría en la depuración del código, la razón es que las versiones más
recientes de este lenguaje unieron paquetes y los nombraron de manera distinta, y en la versión
ya enunciada se encuentran desagregados como consecuencia cada uno lleva un nombre
diferente, a los cuales se remiten la librería principal. Finalmente la plataforma de negociación
Trader WorkStation debe estar abierta y con conexión al momento de ejecutar el código.
97
Pruebas envió de órdenes.
Se pretende a continuación mostrar la salida que deja el programa luego de ejecutarse el código
explicado anteriormente, se proponen cuatro ejemplos cuyo fin es evidenciar la confirmación
satisfactoria de la apertura de posiciones en el mercado.
Divisas.
A continuación se encuentra un ejemplo para él envió de una orden de compra a precio de
mercado de la paridad GBP/USD; en el recuadro de color rojo se puede evidenciar la
confirmación por parte de la plataforma sobre la nueva posición abierta.

98
Figura 25. Ejecución compra paridad GBP/USD. Se evidencia que tras ejecutar el código, la
confirmación de orden llega instantáneamente asegurando que se ha abierto una nueva posición.
Fuente: Spyder (2017)
Acciones.
Se propone abrir una posición de venta de 100 unidades de la acción APPLE, con la moneda
dólar. En la parte inferior derecha de la siguiente imagen se muestra una ventana emergente que
confirma la apertura de dicha posición.
Figura 26. Confirmación posición acciones AAPL. Se observa la confirmación del envió de la
orden desde el lenguaje de programación al API de Interactive Brokers. Fuente: Spyder (2017).
99
Commodities.
Se plantea a continuación un ejemplo de acuerdo al envió de una orden de un commodities, para
este caso el oro (XAUUSD) una posición de compra de 100 unidades. La confirmación de la
orden nuevamente se da instantáneamente y se refleja en el recuadro rojo de la parte inferior
derecha de la siguiente imagen.
Figura 27. Confirmación orden XAUUSD. Se puede apreciar la interfaz del lenguaje de
programación Python, junto a la confirmación de la orden ejecutada. Fuente: Spyder (2017).
Bonos.
100
Se presenta enseguida un ejemplo de envió de orden para United Stated Treasury, y cuyo
símbolo dentro de la plataforma es “912828C57”, la posición a tomar es compra. En el recuadro
de la parte inferior derecha se encuentra la confirmación de esta orden al mercado.
Figura 28. Confirmación orden de bonos. Se puede apreciar la manera en la cual se hace la
confirmación de la orden enviada desde Python a la plataforma de negoción Trader Workstation.
Fuente: Spyder (2017).
Luego del envió de cada una de estas órdenes, si se desea se puede reafirmar la apertura
de cada una, abriendo la plataforma de negociación Trader WorkStation en la parte inferior
izquierda.
101
Figura 29. Verificación en la plataforma de las órdenes abiertas. Nótese la parte inferior
derecha de la imagen se encuentra cada una de las operaciones realizadas desde el lenguaje de
programación Python.
Información Histórica.
Para poder obtener la información histórica, fue necesario tener como plantilla un código
postulado en un foro virtual de programadores (Fundamental Data Using IbPy, 2017) y se ajustó
con lo explicado en la guía práctica suministrada por Interactive Brokers (Interactive Brokers,
s.f).
102
En método principal del código se establece primero la conexión, se realiza
suministrando los mismo datos que en la sección anterior, posterior a esto hace el llamada de la
función que imprime los errores o procedimientos que están siendo ejecutados con el servidor, la
siguiente sentencia encontrada allí, será la invocación seguida de la función
“historicalData_handler” que es la encargada de imprimir toda la información requerida como lo
es fecha, open, high, low, close, volumen, y a la vez llamando al método de librería “message”
que hace posible poder obtener esta información, para luego realizar la conexión.
El paso siguiente será especificar el activo , su clasificación y enrutador, con base a los
ejemplo dados en la sección anterior, del cual se desea obtener dicha información, para luego
poder invocar la función “reqHistoricalData”, en la cual se especiará cuando tiempo atrás desea
la información en segundos (“S”),días (“D”), semanas (“W”), meses (“M”) o años (“Y”), el
marco de tiempo o tamaño de la vela que puede ser por segundos ( “1 secs”, “5 secs”, “10 secs”,
“15 secs”, “30 secs”), minutos (“1 min”, “2 mins”, “3 min”, “5 mins”, “10 mins”, “15 mins”, “20
mins”, “30 mins”), horas (“1 hour”, “2 hours” , “3 hours”, “4 hours” , “8 hours”), días (“1 day”) ,
semanas (“1 week”) y meses (“1 month”), y finalmente el tipo de información histórica ya se
“TRADES”, “MIDPOINT”, “BID”, “ASK” entre otros, finalmente de desconecta del servidor.
(Anexo N). Es necesario que el usuario se remita a la guía pues allí encontrará información más
detallada que no es pertinente aclarar en este documento, pues no es pertinente con el centro de
investigación. (Guía TWS).

103
Figura 30. Ejecución información histórica. Se puede evidenciar la salida señalada por el
cuadro rojo, luego de la ejecución del código simbolizado por el cuadro azul. Fuente: Spyder
(2017).
Como se puede observar en la gráfica anterior, luego de ejecutar el código en el cual se
solicitaba la información histórica de una semana atrás con un marco de tiempo de cuatro horas
para la paridad EUR/USD, la salida de este código se ve reflejado en la parte inferior derecha de
la imagen, es evidente como el primer valor que muestras es la fechas, seguido de la hora, open,
high, low, close.

104
Información Tiempo Real.
Con el fin de obtener la información en tiempo real del activo deseado, fue nuevamente
necesario acoger la propuesta realizada en el foro virtual como malla (Fundamental Data Using
IbPy, 2017), y a partir de esta empezar a estructurarlo. Fue necesario principalmente la guía
virtual de código para Trader Workstation (Interactive Brokers, s.f), la cual referenció la librería
que se debía usar y las condiciones que esta llevaría; dentro de la búsqueda de información que
permitiera obtener los precios en tiempo real, fue oportuno encontrar otra propuesta de código,
que ayudo a encontrar la metodología para la impresión de los precios negociados en tiempo real
(ibpy: extract API responses for multiple contracts, s.f).
Dentro del método principal de este código, se encuentra la primer sentencia que hace
alusión a la conexión con la plataforma, al igual que se hizo en secciones anteriores, es necesario
suministrar al programa el puerto al cual se encuentra conectado la plataforma y el clienteId
asignado, en segundo lugar se invocó la función “error_handler” cuyo objetivo es retornar los
errores o el estado de solicitudes al servidor, de igual manera en la siguiente sentencia del código
se invoca la función “realData_handler” que imprimirá la información recibida por el servidor,
pero poder ejecutar esta función es necesario el uso de otra librería y dos funciones en
específicas “message.tickSize” y “message.tickPrice”; el paso a seguir es establece la conexión
con el API.
105
Para poder obtener los datos de tiempo real es necesario especificar el activo del cual se
requiere esta información, para esto se ha definido las siguientes cinco líneas. Luego de esto se
invoca la función que permite solicitar a la plataforma de negociación los precios de mercado
“reqMktData”, los valores que la retroalimentan y que permiten conseguir la información
deseada por el usuario van dentro de un paréntesis; el primer espacio para rellenar hace
referencia a un requisito de identificación (“1”), el siguiente es el llamado a la variable que tiene
almacenada la información del activo del cual se desea saber, en el tercer espacio se especifica
que puntualmente el dato que se desea saber, para el ejemplo que se dará en seguida se escogió
(“221”) pues este hace referencia a los precios de mercado, para ver más opciones acerca de esta
función consultar la guía ( Guía TWS- reqMktData). Finalmente se procede a desconectarse del
API.
106
Figura 31. Recepción datos tiempo real. Se observa en la parte inferior derecha en el recuadro
rojo la información proveniente de la ejecución del código. Fuente: Spyder (2017).
En el gráfico anterior se puede evidencia la salida que tuvo la ejecución el código, donde se
solicitó precios de mercado para la paridad EUR/USD, la impresión de esta información se ve
demarcada en el recuadro rojo de la parte inferior derecha de la imagen, devolviendo así la
información requerida y de manera satisfactoria. (Anexo O).
De esta manera se logra una conexión verídica entre el lenguaje de programación Python
y la plataforma de negociación Trader Workstation, que permite hacer frente a las problemáticas
inicialmente enunciadas.
107
Conclusiones.
La implementación del modelo Backtesting en el lenguaje de programación Python permitió
validar los resultados obtenidos en la investigación principal de referencia y actualizar las bases
de datos, con el fin de poder analizar los nuevos resultados arrojados, donde se pudo evidenciar
que de acuerdo a la dinámica del mercado las estrategias de inversión pueden ajustarse o no a
este, y como consecuencia repercutir en las utilidades obtenidas por el inversionista.
La ejecución del modelo Backtesting permite tener resultados en un menor tiempo, con
apertura de procesos simultáneos, y un rango amplio de configuración para cada componente del
indicador técnico Ichimoku Kinko Hyo, lo que se transforma en nuevas herramientas para el
inversor, quien debe permanentemente buscar y aprovechar la tecnología para un análisis
cuantitativo profundo y eficaz en los mercados financieros.
En cuanto a la optimización de las estrategias de inversión, se hizo a través de 30
escenarios diferentes cuyo filtro de apertura era el estado del cruce de la Tenkan Sen y Kinjun
Sen respecto a la Kumo, en donde se pudo evidenciar que a medida que aumenta el marco de
tiempo estas muestran mejor desempeño en el mercado.

108
Para todos los casos evaluados los resultados fueron positivos y se evidenció una
eficiencia máxima de 84.51%, lo que permite concluir que el desempeño aumentó como
consecuencia al estado de la Kumo como filtro de apertura, y de acuerdo a los cierres propuestos.
Por otro lado, los lenguajes de programación son nuevos escenarios que deben ser
abordados desde el ámbito académico y personal, pues pueden convertirse en un aliado eficaz
para cualquier inversionista o persona; al ajustar Python como la fuente de desarrollo de esta
investigación, deja abierta una puerta llena de oportunidades donde los ingenieros financieros,
pueden encontrar un desarrollador de herramientas que aportará rapidez, precisión y eficiencia en
cada proceso; esto fue evidenciado con la interconexión entre la plataforma de negociación
Trader Workstation y este lenguaje de programación.

109
Anexos.
Anexo A. Diagrama de flujo modelo Backtesting Python.

Diagrama de flujo 1.xlsx
Anexo B. Código cálculo Tenkan Sen.
def tenkan(lista_precios,par_tenkan):
total_high=np.array([],dtype=Decimal)### se crea una matriz donde seran

guardados los valores high sin dimensiones y de tipo Decimal
total_high.resize(len(lista_precios))## se asigna el tamaño de la matriz
con la longitud de datos del archivo csv
i=0 ## variable que servira como contador para recorrer las listas
for posicion in lista_precios: ## mediante un ciclo se recorre la
lista_precios
total_high[i]=posicion[3] # asignó los valores del archivo csv a la

nueva lista y pongo 3 porque es la ubicacion del high en el archivo csv
i=i+1#contador
total_low=np.array([],dtype=Decimal)### se crea una matriz donde seran

guardados los valores low sin dimensiones y de tipo Decimal
total_low.resize(len(lista_precios))## se asigna el tamaño de la matriz
con la longitud de datos del archivo csv
i=0# variable que servira como contador
for posicion in lista_precios: ## mediante un ciclo se recorre la lista
total_low[i]=posicion[4]# asignó los valores del archivo csv a la

nueva lista y pongo 4 porque es la ubicacion del high en el archivo csv
i=i+1#contador
##declaro variable para el cálculo de la tenkan

i=0 #variable que compone el contador
prom_t=0 #variable de promedio
lista_tenkan=np.array([],dtype=Decimal)### se crea una matriz donde seran
guardados los valores tenkan sin dimensiones y de tipo Decimal
lista_tenkan.resize(len(lista_precios)) #lista en donde se guarda los
valores finales del calculo de la tenkan.
for a,b in zip(total_high, total_low): ## ciclo para recorrer la lista

donde se guardaron los precios de high low
while len (total_high[i:]) >= par_tenkan: # ciclo que tiene una

funcion que se debe cumplir para poder hacer el rsto del procedimeinto: en
este caso la longitud del vector restant por recorrer debe ser mayor o igual
al valor del parametro sumisnistrado por la tenkan.
high= total_high[i:par_tenkan+i] # porcion de la lista que

se debe tomar para el cálculo
low=total_low [i:par_tenkan+i] # porcion de la lista que
110
se debe tomar para el cálculo

prom_t = (Decimal(max(high))+ Decimal(min(low)))/2 ##
calculo de la tenkan usando "Decimal"
lista_tenkan[i+par_tenkan-1]=Decimal(prom_t) ## asigno los
valores del calculo al vector donde serán guardados
i=i+1 # se agregan los valores dela tenkan a una lista
lista_tenkan [:par_tenkan-1]=" " ## relleno de vacio esta magnitud del

vector para que no interfiera en las decisiones de apertura o cierre.
return lista_tenkan , par_tenkan,total_high,total_low

111
Anexo C. Código cálculo Kinjun Sen.
def kinjun(total_high,total_low, par_kinjun):
i=0 #variable que compone un contador

prom_k=0 #variable de promedio
lista_kinjun=np.array([],dtype=Decimal)### se crea una matriz donde seran
guardados los valores kinjun sin dimensiones y de tipo Decimal
lista_kinjun.resize(len(total_high)) #lista en donde se guarda los
valores finales del calculo de la kinjun.
for c,d in zip(total_high, total_low): ## ciclo para recorrer la lista

donde se guardaron los high's y low's
while len (total_high[i:]) >= par_kinjun: # ciclo que tiene una

funcion que se debe cumplir para poder hacer el resto del procedimeinto: en
este caso la longitud del vector restante por recorrer debe ser mayor o igual
al valor del parametro sumisnistrado por la kinjun.
high=total_high[i:par_kinjun+i] # porción de la lista que

se debe tomar para el calculo
low=total_low [i:par_kinjun+i] # porción de la lista que se
debe tomar para el calculo
prom_k = (Decimal(max(high))+ Decimal(min(low)))/2
lista_kinjun[i+par_kinjun-1]=Decimal(prom_k) # se agregan
los valores de la kinjun a una lista
i=i+1# contador
lista_kinjun [:par_kinjun-1]=" " ## relleno de vacio esta magnitud del

vector para que no interfiera en las decisiones de apertura o cierre.
return lista_kinjun,par_kinjun
112
Anexo D. Código cálculo Senkou Span A.
def spana(lista_tenkan,lista_kinjun,par_kinjun,par_ade):

lista_spana=np.array([],dtype=Decimal) ### se crea una matriz donde seran
guardados los valores spana sin dimensiones y de tipo Decimal
lista_spana.resize(len(lista_tenkan)) #lista en donde se guarda los
valores finales del calculo de la spana.
for a, b in zip(lista_tenkan,lista_kinjun) : ## ciclo para recorrer la

lista tenkan y kinjun
while len (lista_kinjun[i+par_kinjun:]) >= par_ade : # ciclo que

tiene una funcion que se debe cumplir para poder hacer el resto del
procedimeinto: en este caso la longitud del vector restante por recorrer debe
ser mayor o igual al valor del parametro sumisnistrado por la spana.
spana= (lista_tenkan[i+par_kinjun-1]+lista_kinjun[i+par_kinjun-
1]) # porción de la lista que se debe tomar para el calculo
total_spana= Decimal(spana/2)
lista_spana[i+par_kinjun+par_ade-1]=Decimal(total_spana) # se
agregan los valores de la kinjun a una lista
i=i+1 # contador
lista_spana [:par_ade+par_kinjun-1]=" " ## relleno de vacio esta magnitud

del vector para que no interfiera en las decisiones de apertura o cierre.
return lista_spana, par_ade

113
Anexo E. Código cálculo Senkou Span B.
def spanb(par_ade,total_high,total_low,par_spanb):

lista_spanb=np.array([],dtype=Decimal) ### se crea una matriz donde seran
guardados los valores spanb sin dimensiones y de tipo Decimal
lista_spanb.resize(len(total_high)) #lista en donde se guarda los
valores finales del calculo de la spanb.
for a, b in zip(total_high,total_low) :
while len (total_low[i:]) >= par_spanb+par_ade:# ciclo que tiene una

funcion que se debe cumplir para poder hacer el resto del procedimeinto: en
este caso la longitud del vector restante por recorrer debe ser mayor o igual
al valor del parametro sumisnistrado por la spanb.
high=total_high[i:par_spanb+i] # porción de la lista que se debe

tomar para el cálculo
low=total_low [i:par_spanb+i] # porción de la lista que se debe
tomar para el cálculo
spanb= Decimal(max(high))+Decimal(min(low))
total_spanb= Decimal(spanb/2)
lista_spanb[i+par_spanb+par_ade-1]=Decimal(total_spanb) # se
agregan los valores de la kinjun a una lista
i=i+1#contador
lista_spanb[:par_spanb+par_ade-1]=" " ## relleno de vacio esta magnitud

del vector para que no interfiera en las decisiones de apertura o cierre.
return lista_spanb , par_spanb

114
Anexo F. Código cálculo Chikou Span.
def chikou (lista_precios,par_ade):
total_close=[] ### se crea una lista con donde seran guardados los
valores high
chikou=[]
for posicion in lista_precios: ## mediante un ciclo se recorre la lista
total_close.append(posicion[5]) # agrego los valores del archivo csv

a la nueva lista y pongo 3 porque es la ubicacion del high en el archivo csv
chikou.append(total_close[par_ade:])
115
Anexo G. Código función posición.
def posicion_lc(lista_precios,lista_kinjun,lista_spana,lista_spanb):
total_fecha=[] ### se crea una lista con donde seran guardados los
valores open
total_open=[] ### se crea una lista con donde seran guardados los valores
open
total_close=[] ### se crea una lista con donde seran guardados los
valores low
for a in lista_precios: ## mediante un ciclo se recorre la lista
total_fecha.append(a[0]) # agrego los valores del archivo csv a la

nueva lista y pongo 2 porque es la ubicacion del open en el archivo csv
total_open.append(a[2]) # agrego los valores del archivo csv a la
nueva lista y pongo 2 porque es la ubicacion del open en el archivo csv
total_close.append(a[5]) # agrego los valores del archivo csv a la
nueva lista y pongo 5 porque es la ubicacion del close en el archivo csv
i=0 #se declara una variable que servirá de contador

posicion=[] ### se crea una lista con donde seran guardados los valores
de posicion (CORTO / LARGO)
for f,o,c,k,a,b in
zip(total_fecha,total_open,total_close,lista_kinjun,lista_spana,lista_spanb):
# se crea un for por medio del cual se va a recorrer las listas de fecha,
open, kinjun … etc. para poder determinar la posicion que se debe tomar
(largo o corta), según corresponda.
if total_fecha [i] != " " and total_open [i]!= " " and lista_kinjun
[i] != "" and lista_spanb [i]!= " ": #condición inicial para seguir el ciclo
es que hayan valores la posicion de la fila
#si cumple la condición anterior entonces se abre un nuevo if
que es donde se determinara la posicion siempre y cuando se cumplan una serie
de condiciones, SI SE CUMPLE LAS CONDICIONES en esta primer parte entonces
tendremos que la posicion es LARGA
if ((Decimal(total_open [i]) > Decimal(lista_spana [i])) and
(Decimal(total_open [i]) > Decimal(lista_spanb [i])) and
(Decimal(lista_kinjun [i]) > Decimal(lista_spana [i])) and
(Decimal(lista_kinjun [i]) > Decimal(lista_spanb [i]))) or \
((str(posicion [i-1]) == "LARGO") and (Decimal(total_open
[i])< Decimal(lista_spana [i])) and (Decimal(total_open [i]) <
Decimal(lista_spanb [i])) and (Decimal(lista_kinjun[i]) > Decimal(lista_spana
[i])) and (Decimal(lista_kinjun [i]) > Decimal(lista_spanb[i]))) or \
[i])>= Decimal(lista_spana [i])) and (Decimal(total_open [i]) <=
Decimal(lista_spanb [i])) and (Decimal(lista_kinjun[i])> Decimal(lista_spana
[i])<= Decimal(lista_spana [i])) and (Decimal(total_open [i]) >=
116
[i])> Decimal(lista_spana [i])) and (Decimal(total_open [i]) >

Decimal(lista_spanb [i])) and (Decimal(lista_kinjun[i]) >=
Decimal(lista_spana [i])) and (Decimal( lista_kinjun [i]) <=
Decimal(lista_spanb[i]))) or \
Decimal(lista_spanb [i])) and (Decimal(lista_kinjun[i]) <=
Decimal(lista_spana [i])) and (Decimal( lista_kinjun [i]) >=
Decimal(lista_spanb [i])) and (Decimal(lista_kinjun[i]) < Decimal(lista_spana
[i])) and (Decimal( lista_kinjun [i]) < Decimal(lista_spanb[i]))):
posicion.append("LARGO")
#si no se cumple alguna condición de la anterior parte del ciclo,
pasara a esta parte y si se cumple la posicion será CORTO
elif ((Decimal(total_open [i]) < Decimal(lista_spana [i])) and
(Decimal(total_open [i]) < Decimal(lista_spanb[i])) and (Decimal(lista_kinjun
[i])< Decimal(lista_spana [i])) and (Decimal(lista_kinjun[i])<
((str(posicion [i-1]) == "CORTO") and (Decimal(total_open
[i])) and (Decimal(lista_kinjun [i]) < Decimal(lista_spanb[i]))) or \
[i])>= Decimal(lista_spana [i])) and (Decimal(total_open [i]) <=
Decimal(lista_spanb [i])) and (Decimal(lista_kinjun[i])< Decimal(lista_spana
[i])<= Decimal(lista_spana [i])) and (Decimal(total_open [i]) >=
Decimal(lista_spanb [i])) and (Decimal(lista_kinjun[i]) >=
Decimal(lista_spana [i])) and (Decimal( lista_kinjun [i]) <=
Decimal(lista_spanb [i])) and (Decimal(lista_kinjun[i]) <=
Decimal(lista_spana [i])) and (Decimal( lista_kinjun [i]) >=
[i])) and (Decimal( lista_kinjun [i]) > Decimal(lista_spanb[i]))):
posicion.append("CORTO")
else:
posicion.append(" ")
else: # si no cumple con la condicional inicial entonces pasar aquí y

dará como resultado una celda vacía
posicion.append(" ")
i=i+1#contador
return total_open, total_close, posicion

117
Anexo H. Código función cierre.
def cierre_lc (total_open,lista_kinjun,lista_spana,lista_spanb,posicion): ##

archivos necesarios para desarrollarla función
i=0 #se declara una variable que servirá de contador

cierre=[] # lista donde almacenare los resultados de los ciclos
for a,b,c,d,e in zip(total_open,lista_kinjun,lista_spana,

lista_spanb,posicion): ## ciclo para poder recorre las listas.
if lista_kinjun [i] != " " and lista_spana [i] != " " and lista_spanb
[i] != " " : ## condición inicial que los valores de la lista en la posicion
i sean diferente a vacío
if (Decimal(total_open [i]) + Decimal (lista_kinjun [i]) +

Decimal (lista_spanb [i])) != 0 : ### segunda condición es que la suma de los
valores de las lista en la posicion de i sea diferente a 0
##tercera condición para poder determinar si el cierre es

corto, se mira le comportamiento de la Kinjun, open, spana y spanb
if ((str(posicion [i-1])=="CORTO") and (Decimal(total_open
[i])>= Decimal(lista_spana [i])) and (Decimal(total_open [i])<=
Decimal(lista_spanb [i])) and (Decimal(lista_kinjun [i])>= Decimal
(lista_spana [i])) and (Decimal(lista_kinjun [i])<= Decimal (lista_spanb
[i]))) or \
((str(posicion [i-1])=="CORTO") and (Decimal(total_open
[i])<= Decimal(lista_spana [i])) and (Decimal(total_open [i])>=
Decimal(lista_spanb [i])) and (Decimal(lista_kinjun [i])<= Decimal
(lista_spana [i])) and (Decimal(lista_kinjun [i])>= Decimal (lista_spanb
[i]))) or \
[i])> Decimal(lista_spana [i])) and (Decimal(total_open [i])>
Decimal(lista_spanb [i])) and (Decimal(lista_kinjun [i])>= Decimal
(lista_spana [i])) and (Decimal(lista_kinjun [i]) <= Decimal(lista_spanb
[i]))) or \
[i])> Decimal(lista_spana [i])) and (Decimal(total_open [i])>
Decimal(lista_spanb [i])) and (Decimal(lista_kinjun [i])<= Decimal
(lista_spana [i])) and (Decimal(lista_kinjun [i]) >= Decimal(lista_spanb
[i]))) or \
[i])>= Decimal (lista_spana [i]))and (Decimal(total_open [i])<=
Decimal(lista_spanb [i])) and (Decimal(lista_kinjun [i])> Decimal
(lista_spana [i])) and (Decimal(lista_kinjun [i]) > Decimal(lista_spanb
[i]))) or \
[i])<= Decimal (lista_spana [i]))and (Decimal(total_open [i])>=
Decimal(lista_spanb [i])) and (Decimal(lista_kinjun [i])> Decimal
(lista_spana [i])) and (Decimal(lista_kinjun [i]) > Decimal(lista_spanb
[i]))):
cierre.append("CIERRE CORTO") ## si se cumple alguna de
las condiciones anteriores , entonces el será CIERRE CORTO y se agregara a la
lista
# si no se cumple la condición anterior entonces pasara a esta parte del
118
ciclo
elif ((str(posicion [i-1])=="LARGO") and (Decimal(total_open
[i]) >= Decimal(lista_spana [i])) and (Decimal (total_open [i])<=
Decimal(lista_spanb [i])) and (Decimal (lista_kinjun [i]) >=
Decimal(lista_spana [i])) and (Decimal (lista_kinjun [i]) <=
Decimal(lista_spanb [i]))) or \
((str(posicion [i-1])=="LARGO") and (Decimal(total_open
[i]) <= Decimal(lista_spana [i])) and (Decimal (total_open [i])>=
Decimal(lista_spanb [i])) and (Decimal (lista_kinjun [i]) <=
Decimal(lista_spana [i])) and (Decimal (lista_kinjun [i]) >=
[i]) < Decimal(lista_spana [i])) and (Decimal (total_open [i])<
Decimal(lista_spanb [i])) and (Decimal (lista_kinjun [i]) >=
Decimal(lista_spana [i])) and (Decimal (lista_kinjun [i]) <=
[i]) < Decimal(lista_spana [i])) and (Decimal (total_open [i])<
Decimal(lista_spanb [i])) and (Decimal (lista_kinjun [i]) <=
Decimal(lista_spana [i])) and (Decimal (lista_kinjun [i]) >=
[i]) >= Decimal(lista_spana [i])) and (Decimal (total_open [i])<=
Decimal(lista_spanb [i])) and (Decimal (lista_kinjun [i]) <
Decimal(lista_spana [i])) and (Decimal (lista_kinjun [i]) <
[i]) <= Decimal(lista_spana [i])) and (Decimal (total_open [i])>=
Decimal(lista_spanb [i])) and (Decimal (lista_kinjun [i]) <
Decimal(lista_spana [i])) and (Decimal (lista_kinjun [i]) <
Decimal(lista_spanb [i]))):
cierre.append("CIERRE LARGO")## si se cumple alguna de
las condiciones de esta parte del ciclo entonces será CIERRE LARGO y se
agregara a la lista cierre
## si no se cumple la primera y la segunda condición entonces
pasara aquí
elif ((str(posicion [i-1])=="LARGO") and (str(posicion
[i])=="CORTO")):
cierre.append("CIERRE LARGO") ##si se cumple la condición
de esta parte del ciclo , entonces será CIERRE LARGO
## si no se cumple la primer o la segunda o la tercera
entonces pasara aquí
elif ((str(posicion [i-1])=="CORTO") and (str(posicion
[i])=="LARGO")):
cierre.append("CIERRE CORTO")##si se cumple la condición
de esta parte del ciclo entonces será CIERRE CORTO
#si no se cumplió ninguna de las condiciones anteriores
entonces entra aquí
else:
cierre.append(" ") ## se agrega el resultado a la lista
else:
cierre.append(" ")
## si no se cumplió la condición inicial que permitía entrar a los
otros ciclo entonces pasara acá
else:
cierre.append(" ") # se agrega " " (vacío) a la lista cierre
119
i=i+1 # contador
return cierre
120
Anexo I. Código función apertura.
def apertura_lc(lista_tenkan, lista_kinjun, lista_spana, lista_spanb,

posicion): # lista que necesito para desarrollar la función
i=0 # variable de contador
apertura=[] # creo la lista de apertura que tendrá valores de (APERTURA-
LARGO,APERTURA-CORTO)
for a,b,c,d,e in zip(lista_tenkan, lista_kinjun, lista_spana,

lista_spanb, posicion): ## ciclo para poder recorrer las listas.
#condición inicial del ciclo que consiste en que los valores de las
listas en la posicion i sean diferentes a vacío
if lista_tenkan [i] != "" and lista_kinjun [i] != "" and lista_spana
[i] != "" and lista_spanb [i] != "" :
# si se cumple la condición inicial pasan aquí
if ((posicion[i-1]==" ") and ((posicion [i])=="LARGO")) or
(((posicion[i-1]=="CORTO")) and ((posicion [i])=="LARGO")):
apertura.append("APERTURA LARGO") # se agrega APERTURA LARGO
pues cumplió con las condiciones del ciclo
#si no cumple la condición anterior, entonces pasa a esta parte

del ciclo .
elif ((posicion[i-1]==" ") and ((posicion [i])=="CORTO")) or
(((posicion[i-1]=="LARGO")) and ((posicion [i])=="CORTO")):
apertura.append("APERTURA CORTO") # si se cumple se agregara
en la lista APERTURA CORTO
else:
apertura.append(" ")
# si no cumple la condición inicial entonces pasa aquí

else:
apertura.append(" ") # se agrega "" (vacío) en la lista
i=i+1 # contador
return apertura
121
Anexo J. Código función de resultados.
def pips
(total_open,total_close,cierre,apertura,posicion,par_tenkan,par_kinjun,par_ad
e,par_spanb,k,eficiencia,mayor,par_optimo):
## CORTOOOO
###CREO LAS LISTAN ES LAS QUE se almacenara los open y close de las
posiciones cortas
oac =[] #OAC = OPEN-APERTURA-CORTO
ccc =[] #CCC = CLOSE-CIERRE-CORTO
i=0 # creo la variable del contador
for aper,close in zip(apertura,cierre):# creo un ciclo con el que se

recorrerá la lista
if apertura[i]==("APERTURA CORTO"): # condicional que valida si en la

posicion i de la lista apertura es igual a APERTURA CORTO
oac.append(total_open[i]) #si se cumple la condición anterior
entonces agregara el open de la posición en la cual se encontró el indicador
APERTURA CORTO
if cierre[i]=="CIERRE CORTO": # condicional que valida si en la

posicion i de la lista apertura es igual a CIERRE CORTO
ccc.append(total_open[i]) #si se cumple la condición anterior
entonces agregara el close de la posición en la cual se encontró el indicador
CIERRE CORTO
i=i+1 # contador que recorre la lista
rentshort = [] # lista en donde almacenare los resultados de cada

operación
for a,b in zip(oac,ccc): # creo un ciclo con el que se recorrerá la lista
gan= ((Decimal(oac[i])-Decimal(ccc[i]))*10000)-3 # operación de open

y close en la posicion corto para sacar la ganancia por trades
rentshort.append(gan) #agrego el resultado a la lista RENTSHORT
i=i+1 #contador que recorre la lista
## LARGOOO
oal =[] #OAC = OPEN-APERTURA-LARGO
ccl =[] #CCC = CLOSE-CIERRE-LARGO
i=0 # contador que recorre la lista

for aper,close in zip(apertura,cierre): # creo un ciclo con el que se
recorrerá la lista
if apertura[i]==("APERTURA LARGO"): # condicional que valida si en la

posicion i de la lista apertura es igual a APERTURA LARGO
oal.append(total_open[i]) #si se cumple la condición anterior
entonces agregara el open de la posición en la cual se encontró el indicador
122
APERTURA LARGO
if cierre[i]=="CIERRE LARGO": # condicional que valida si en la

posicion i de la lista apertura es igual a CIERRE LARGO
ccl.append(total_open[i]) #si se cumple la condición anterior
entonces agregara el close de la posición en la cual se encontró el indicador
CIERRE LARGO
i=i+1 # contador que recorre la lista
rentlong = [] # lista en donde almacenare los resultados de cada

operación
for a,b in zip(oal,ccl): # creo un ciclo con el que se recorrerá la lista
gan= ((Decimal(ccl[i])-Decimal(oal[i]))*10000)-3 # operación de open

y close en la posicion corto para sacar la ganancia por trades
rentlong.append(gan) #agrego el resultado a la lista RENTLONG
i=i+1 #contador que recorre la lista
#print("GANANCIA-PERDIDA POSICIÓN LARGO")
#print(rentlong) #imprimo la lista en la que la están almacenándose la
ganancia-perdida de las posiciones largas
#### RESULTADO PIPS
totalc= sum(rentshort) ## suma de la rentabilidad de los cortos

totall=sum(rentlong) ## suma de la rentabilidad de los largos
total= totalc+totall ## suma de la rentabilidad de los largos y cortos
resumen.append(total)
print("RESULTADO : ", total) # imprimo el resultado
##### TRADE POSITIVOS-NEGATIVOS POSICION CORTA
tpc=0
tnc=0
i=0
for a in rentshort: ## creo un ciclo para recorrer las lista de
rentabilidad corto para sacar trades positivos y negativos de la posicion
corto
if rentshort [i] > 0:
tpc=tpc+1
if rentshort [i] < 0:

tnc=tnc+1
i=i+1
print("TRADE POSITIVOS POSICIONES CORTAS :", tpc)
print("TRADE NEGATIVOS POSICIONES CORTAS :", tnc)
resumen.append(tpc)
resumen.append(tnc)
##### TRADE POSITIVOS-NEGATIVOS POSICION LARGA
tpl=0
tnl=0
i=0
for a in rentlong: ## creo un ciclo para recorrer las lista de
rentabilidad corto para sacar trades positivos y negativos de la posicion
123
largo
if rentlong [i] >= 0:
tpl=tpl+1
if rentlong [i] <= 0:

tnl=tnl+1
i=i+1
print("TRADE POSTIVOS POSICIONES LARGAS :", tpl)
print("TRADE NEGATIVOS POSICIONES LARGAS :", tnl)
resumen.append(tpl)
resumen.append(tnl)
###### TOTAL TRADE
ttlc= tpc+tnc+tpl+tnl ## sumo el total de trade tanto positivos como

negativos en las dos posiciones (LARGA -CORTA)
print("TOTAL TRADE :", ttlc)
resumen.append(ttlc)
###### EFICIENCIA
#### EN ESTA PARTE DE LA FUNCIÓN HAGO UN CICLO PARA PODER COMPARA LA
EFICIENCIA QUE VAN TENIENDO DE ACUERDO A LAS PARAMETROS SUMINISTRADOS .
ef=((tpl+tpc)/ttlc)*100 ## sumo los trades POSITIVOS de posiciones larga
y corta y lo divido en el total de trade
print("EFICIENCIA :", ef ,"%")
eficiencia.append(ef)
resumen.append(ef)
## FOR PARA RECORRER LA LISTA EFICIENCIA, IF PARA HACER LA LOGICA Y ESCOGER
EL MAYOR, SI SE CUMPLE HARA EL PROCEDIMIENTO DE ABAJO.
for ee in eficiencia:
if (Decimal (eficiencia[k]) > Decimal(mayor)) :
mayor=eficiencia[k]
del par_optimo [:]

par_optimo.append(par_tenkan)
par_optimo.append(par_kinjun)
par_optimo.append(par_ade)
par_optimo.append(par_spanb)
#tickerop = ticker
### MAXIMO TRADE
maximo= max(max(rentshort),max(rentlong)) ##maximo de todos los trade

print("TRADE MAXIMO :", maximo)
resumen.append(maximo)
### MINIMO TRADE
minimo= min(min(rentshort),min(rentlong)) ##minimo de todos los trade

print("TRADE MINIMO :", minimo)
resumen.append(minimo)
###PROMEDIO
promc= sum(rentshort)/len(rentshort)
proml= sum(rentlong)/len(rentlong)
prom= ((promc+proml)/2) ##promedio de todos los trade
print("PROMEDIO TRADE :", prom)
124
resumen.append(prom)
return eficiencia,par_optimo,mayor,resumen
125
Anexo K. Código función agregar y escribir
def agregar (lista_tenkan,lista_kinjun, lista_spana,

lista_spanb,posicion,cierre,apertura,lista_precios):
i=0
w=0
## se crea el ciclo mediante el cual se recorre la lista para ser
agregadas al archivo principal.
for p,t,k,a,b,p,c,a in zip(lista_precios,lista_tenkan,lista_kinjun,
lista_spana,lista_spanb,posicion,cierre,apertura):
lista_precios[i].append(lista_tenkan[w])
lista_precios[i].append(lista_kinjun[w])
lista_precios[i].append(lista_spana[w])
lista_precios[i].append(lista_spanb[w])
lista_precios[i].append(posicion[w])
lista_precios[i].append(cierre[w])
lista_precios[i].append(apertura[w])
i=i+1 #contador
w=w+1 #contador
return lista_precios
def EscribirCSV(archivo_csv,lista_precios):
#se crea un archivo para escribirlo

with open(archivo_csv, 'w',newline='') as archivo_csv:
## se invoca la función writer
writer = csv.writer(archivo_csv, dialect='excel')
## se agrega la información de las filas
for fila in lista_precios:
writer.writerow(fila)
return
126
Anexo L. Código descargue información online.
def get_data(symbol,start_date,end_date):
### INVOCO LA LIBRERIA, SIMBOLO, ESPECIFICO QUE ES DE YAHOO, FECHA EN QUE
INCIA Y TERMINA.
dat=data.DataReader(symbol, "google", start_date, end_date)
return dat
ACCI =["GOOG","AAPL","MSFT"] ## se crea una lista para que el usuario digite

los nemotécnicos del activo que desea descargar.
comienzo=datetime(2016,1,1) ## fecha en la que se comienza la descarga de
información, (AÑO, MES, DIA)
fin =datetime.today() ## fecha en la que termina la descarga de información.
## SE CREA UN FOR QUE RECORRE LA LISTA DE ACCI Y GENERA UN ARCHIVO CSV CON EL
NOMBRE DE CADA ACCION
for ticker in ACCI:
DF=get_data(ticker,comienzo, fin)# INVOCO LA FUNCIÓN
## se crean estas listas para almacenar también la información y usarlas
para el procedimiento del resto del código
total_fecha=[]
total_fecha2=[]
total_open=[]
total_high=[]
total_low=[]
total_close=[]
fh= open("%s.csv" % ticker,"w+") # se crea el archivo .csv con el nombre

de cada activo para almacenar allí la función.
for i,date in enumerate (DF.index): # ciclo que permítela descarga de

información, comenzando por la fecha, luego open, high, low, close, volumen.
fh.write("%s,%s,%.2f,%.2f,%.2f,%.2f,%d\n" %
(date.strftime("%Y%m%d"),date.strftime("%Y%m%d"),DF["Open"][i],DF
["High"][i],DF["Low"][i],DF ["Close"][i],DF["Volume"][i]))
a=[date.strftime("%Y%m%d"),date.strftime("%Y%m%d"),DF["Open"][i],DF
["High"][i],DF["Low"][i],DF ["Close"][i],DF["Volume"][i]]
## se extrae la información para almacenarla en las listas creadas.
total_fecha.append(a[0])
total_fecha2.append(a[1])
total_open.append(a[2])
total_high.append(a[3])
total_low.append(a[4])
total_close.append(a[5])
127
Anexo M. Código conexión y envió de órdenes.
def error_handler(msg):
# Función para capturar los errores
print ("Server Error: %s" % msg)
def reply_handler(msg):
# Función para recibir la respuesta por parte del servidor en relación a
los errores o a la ejecución de las ordenes.
print ("Server Response: %s, %s" % (msg.typeName, msg))
def create_contract(symbol, sec_type, exch, prim_exch, curr):

#Función en la cual se invocan funciones para hacer verídica la conexión,
la entrada de esta función será el símbolo del activo en el cual se va a
invertir, la clasificación que este recibe dentro del mercado, el enrutador y
la moneda en la que se va a realizar la posicion.
contract = Contract()
contract.m_symbol = symbol
contract.m_secType = sec_type
contract.m_exchange = exch
contract.m_primaryExch = prim_exch
contract.m_currency = curr
return contract
def create_order(order_type, quantity, action):
## Esta función permite la asignación del tipo de orden, la cantidad y la

definir si es compra o venta.
order = Order()
order.m_orderType = order_type
order.m_totalQuantity = quantity
order.m_action = action
return order
## Este es el método principal y por el medio del cual se llamara cada una de
las anteriores funciones.
if __name__ == "__main__":
## es aquí en esta sentencia donde se debe poner el puerto y el cliente
Id dado en los ajustes de la plataforma
tws_conn = Connection.create(port=7497, clientId=889)
## Se establece la conexión
tws_conn.connect()
## Se invoca la función para ver los errores o la información proveniente
del servidor
tws_conn.register(error_handler, 'Error')
tws_conn.registerAll(reply_handler)
## Se asigna uno a la order_id.
order_id =1
## se crea la variable “contract” con el fin de que almacene la
información de la función “créate_contract”, se observa como además se
establece que el activo a negociar será la divisa GBPUSD cuyo clasificación
128
dentro de Interactive Brokers es “CASH” y el enrutador “IDEAL PRO”

contract = create_contract('GBP', 'CASH', 'IDEALPRO', 'IDEALPRO', 'USD')
## se crea la variable “order” con el fin de que almacene la información
de la función “créate_order”, se observa como además se establece que será un
orden a precio de mercado “MKT” que la cantidad será 100 y que será una
operación de venta “SELL ”
order = create_order('MKT', 100, 'SELL')
##Se invoca la función placeOrder que viene por defecto dentro de las
librerías y cuya función en enviar la orden
tws_conn.placeOrder(order_id, contract, order)
# Se desconecta de la plataforma.
tws_conn.disconnect()
129
Anexo N. Código Información Histórica
def historicalData_handler(msg):
print ([msg.reqId, msg.date, msg.open, msg.high,msg.low, msg.close])
print(msg)
tws = ibConnection(port=7497, clientId=889)

tws.register(error_handler, message.Error)
tws.register(historicalData_handler, message.historicalData)
tws.connect()
c = Contract()
c.m_symbol = 'EUR'
c.m_secType = 'CASH'
c.m_exchange = "IDEALPRO"
c.m_currency = "USD"
tws.reqHistoricalData("", c, "" , '1 W', '4 hours', 'MIDPOINT', 1 , 1)

sleep(1)
tws.disconnect()
130
Anexo O. Código Información tiempo real.
def realData_handler(msg):
# Función que imprime los valores solicitados
inside_mkt_bid = ''
inside_mkt_ask = ''
## se pone como condicional el field. 1 significa el precio BID y 2 el
precio ASK
if msg.field == 1:
inside_mkt_bid = msg.price
## Para facilidad en el comprensión de la salida del código re
antepone la palabra "BID"
print 'bid', inside_mkt_bid
elif msg.field == 2:
inside_mkt_ask = msg.price
## Para facilidad en el comprensión de la salida del código re
antepone la palabra "ASK"
print 'ask', inside_mkt_ask
#print ([msg.tickerId,msg.price])
## Función que imprimir los errores o proceso de solicitud con la
plataforma
print(msg)
## realizar la conexión con la plataforma

tws = ibConnection(port=7497, clientId=889)
# se invoca la función "error_handler"
tws.register(error_handler, message.Error)
## se invoca la función "realData_handler", pero para poder ser ejecutada he
imprimir los valores requeridos necesita de las siguientes dos librerías que
invocan la función de "tickSize" y "tickPrice"
tws.register(realData_handler, message.tickSize, message.tickPrice)
tws.connect()
## se especifica el activo del cual se requiere recibir información
c = Contract()
c.m_symbol = 'EUR'
c.m_secType = 'CASH'
c.m_exchange = "IDEALPRO"
c.m_currency = "USD"
## se invoca la función que realiza la solicitud a la plataforma, y se le

pide "233" es decir precio de mercado.
tws.reqMktData(1,c,"233",False)
sleep(1)
#se desconecta de la plataforma
tws.disconnect()
131
Bibliografía
Admiral Markets AS. (s.f). Obtenido de Opere en Forex con estrategias de Ichimoku:
old.admiralmarkets.es/downloads/es/Opere_en_Forex_con_Estrategias_de_Ichimoku.pdf
Almgren, R., & Lorenz, J. (2007). Adaptive Arrival Price. Algorithmic Trading III.
Balaguera Mesa, D. R. (2015). Estrategias de trading para la paridad EUR/USD a través de la optimización
del indicador Ichimoku Kinko Hyo e implementación de trading Algoritmico. Bogotá.
Balaguera Mesa, D. R. (2015). Estrategias de trading para la paridad EUR/USD a través de la optimización
del indicador Ichimoku Kinko Hyo e implementación del trading algoritmico.
British Broadcasting Corporation (BBC). (06 de Febrero de 2016). Obtenido de Algoritmos, las reglas
secretas de la vida moderna.:
www.bbc.com/mundo/noticias/2016/02/160202_algoritmos_dirigen_vidas_finde_dv
David. (06 de Abril de 2017). Download Price Data From Yahoo API with Python and Use in Build Alpha.
Obtenido de https://www.youtube.com/watch?v=oBRxaibNiaY
del Rio Miño, J. (Junio de 2015). Analisis y comparativa de sistemas automaticos de trading frente al
trading discrecional. Madrid, España.
Fundamental Data Using IbPy. (2017). Obtenido de

https://stackoverflow.com/questions/40645067/fundamental-data-using-ibpy
Halls Moore, M. L. (2015). Successful Algorithmic Trading.
Hendershott, T., Jones, C., & Menkveld, A. (2011). Does Algorithmic Trading Improve Liquidity?
ibpy: extract API responses for multiple contracts. (s.f). Obtenido de

https://stackoverflow.com/questions/30130319/ibpy-extract-api-responses-for-multiple-
contracts
Instituto de Inversiones Bursatiles y Trading . (s.f). Backtesting. Obtenido de

https://institutoibt.com/blog/sobre-el-backtesting/
Interactive Brokers. (s.f). Trader Workstation. Obtenido de https://interactivebrokers.github.io/tws-

api/index.html#gsc.tab=0
Kirilenko, A., & Lo, A. (2013). Moore's law versus Murphy's Law: Algorithmic trading and its discontents.
The Journal of Economic Perspectives.
Loaiza Palacios, D. (2007). Sistemas de analisís técnico para activos de renta variable. Medellín,
Colombia.
Lorenz, J. (2008). Optimal Trading Algorithms: Portfolio Transactions, Multiperiod Portfolio Selection,
and Competitive Online Search.
Maureen , O., Lopéz de Prado, M., & Easley, D. (2013). High-Frequency trading-New Realities for Traders,
Markets and Regulators.
132
Metatrader. (2016). Ichimoku Kinko Hyo. Obtenido de

http://www.metatrader5.com/es/terminal/help/indicators/trend_indicators/ikh
Patel, M. (2010). Wiley Trading: Trading with Ichimoku Clouds: The Essential Guide to Ichimoku Kinko
Hyo Technical Analysis. Hoboken, US:Wiley.
Python Software Foundation. (2017). CSV File Reading and Writing. Obtenido de
https://docs.python.org/3.5/library/csv.html
QuantStart. (s.f). Using Python, IBPy and the Interactive Brokers API to Automate Trades. Obtenido de
https://www.quantstart.com/articles/using-python-ibpy-and-the-interactive-brokers-api-to-
automate-trades
Sánchez Silva, M., & Díaz Mondragón, M. (06 de Julio de 2007). La innovación tecnológica y los mercados
bursatiles. Noticias Financieras.
Seo, J., & Chai, S. (2013). The role of tragorithmic trading systems on stock market efficiency.
Stackoverflow. (s,f). ibpy: extract API responses for multiple contracts. Obtenido de
https://stackoverflow.com/questions/30130319/ibpy-extract-api-responses-for-multiple-
contracts
The PyData Development Team. (2015). Remote Data Access. Obtenido de http://pandas-
datareader.readthedocs.io/en/latest/remote_data.html#remote-data-google

PDF

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

PDF

Cargado por

Copyright:

Formatos disponibles

1

AUTOMATIZACIÓN Y OPTIMIZACIÓN DE SISTEMAS DE

LEIDY KATHERINE BUITRAGO RAMIREZ

UNIVERSIDAD PILOTO DE COLOMBIA.

AUTOMATIZACIÓN Y OPTIMIZACIÓN DE SISTEMAS DE

LEIDY KATHERINE BUITRAGO RAMIREZ

Trabajo de grado para obtener el título de Ingeniera Financiera

Asesor: GIOVANNY MORENO BUITRAGO

UNIVERSIDAD PILOTO DE COLOMBIA.

Descarga de Base Histórica de activos online ..................................................................................... 88

Esta investigación propone un modelo Backtesting en el lenguaje de programación Python que

permite evaluar el desempeño de 30 estrategias propuestas para la paridad EUR/USD en el

entre este lenguaje de programación y la plataforma de negociación Trader Worstation.

programming language and the trading platform Trader Worstation.

En esta investigación se propone la creación de un modelo Backtesting que permite validar,

actualizar y optimizar estrategias de inversión para la paridad EUR/USD bajo el indicador

técnico Ichimoku Kinko Hyo; adicionalmente se plantea un prototipo de interconexión entre el

lenguaje de programación Python y la plataforma de inversión Trader Workstation. El

documento se encuentra dividido en tres secciones:

Capítulo 1: En este apartado se presenta la creación del modelo Backtesting en el lenguaje de

Capítulo 2: En esta sección se puede evidenciar el proceso optimización de nuevas estrategias de

Capítulo 3: Se expone la manera mediante la cual se logra la interconexión con la plataforma de

negociación Trader Workstation y el lenguaje de programación Python, que permite a su vez la

recepción de información histórica, tiempo real y él envió de órdenes de mercado.

Planteamiento del problema.

En la actualidad, los trades al momento de abrir posiciones se enfrentan a tres inconvenientes: El

primero, la subjetividad en la toma de decisiones de inversión; el segundo, los riesgos operativos

asociados al operador que pueden materializarse en la disminución sustancial en las

“físicos” respecto a las ejecuciones automáticas generadas por algoritmos en cuanto a la

diferencia en el número de operaciones realizadas por unidad de tiempo (velocidad) y latencia de

Investigaciones como “Análisis y comparativa de los sistemas automáticos de trading frente al

la inseguridad, el miedo, la frustración, el estrés, la intuición, el cansancio, la distracción, la

soberbia, entre otras, desencadenan en la subjetividad en el proceso de toma de decisiones, en el

En consecuencia, el posicionamiento de los sistemas automáticos ha venido aumentando

comportamiento también se encuentra relacionado con el tiempo de ejecución de órdenes

representado en milésimas de segundo por medio de algoritmos.

Este tipo de trading requiere de patrones objetivos en las variables involucradas en la

“Estrategias de trading para la paridad EUR/USD a través de la optimización del indicador

miembro del grupo de semillero de investigación ARISTOS del Programa de Ingeniería

Financiera de la Universidad Piloto de Colombia. En ésta, se realizó un modelo con algoritmos

se planteó el código en el lenguaje MQL4 para poder modificar el indicador en la plataforma

configuraciones sugeridas, es importante evaluar nuevos escenarios y comportamientos del

proceso de optimización de la estrategia permite aumentar el nivel de desempeño de la misma.

Si bien, la investigación de referencia, logra implementar la estrategia en el lenguaje de

programación MQL4 de la plataforma de negociación Metatrader 4, se considera pertinente

involucrar a la estrategia de inversión; adicionalmente, se considera que el Bróker es la principal

contraparte y si se le brinda la identidad de cada una de las variables mencionadas anteriormente

el margen de superioridad para este sería superior frente al cualquier inversionista.

Por tanto, para la presente investigación será abordado el lenguaje de programación

herramienta de libre acceso.

Pretendiendo hacer un modelo asequible a varios sistemas operativos, se selecciona la

compañía Interactive Brokers como intermediario oficial de la investigación y la plataforma de

commodities, bonos),ejecución instantánea de las ordenes, bajos costos de ejecución,

herramientas fundamentales y técnicas competitivas que permiten el seguimiento constante de

los instrumentos disponibles, trayectoria en el mercado y acceso abierto a la información por

medio de varios lenguajes de programación. A continuación se presenta un diagrama en el cual

se sintetiza de descripción del problema de investigación.

Descripción del problema de investigación.

Diagnostico. Causas. Pronostico. Control de pronostico.

Falta de evaluación Oportunidades nuevas de Es importante asumir los

De acuerdo al planteamiento del problema la pregunta a resolver es ¿Cuál es el

desempeño (medido por rentabilidad, eficiencia y esperanza matemática), del indicador de