Del básico al intermedio: Indicador (I)

En el artículo anterior, "Del básico al intermedio: Eventos (II)", vimos cómo mantener algún tipo de información de forma más o menos permanente entre distintos momentos de uso de la plataforma MetaTrader 5. Sé que algunos pueden pensar que este tipo de contenido es innecesario. Aunque, cuando necesites mantener alguna información entre llamadas, te acordarás de aquello y dirás: «Amigo, gracias por haberme dado ese consejo. De verdad, muchas gracias». De todas formas,

apenas estamos comenzando nuestra exploración. Como ya tenemos algunos conceptos básicos que nos permiten crear pequeños programas y ya hemos visto cómo funciona la programación basada en eventos, ha llegado el momento de entender algunos conceptos básicos que muchas personas intentan implementar, aunque ya han sido pensados y que, por defecto, no necesitas implementar, solo utilizar cuando sea necesario.

En este caso, me refiero a las pestañas que están presentes por defecto en prácticamente todas las aplicaciones de MetaTrader 5, aunque puede que tengamos más o menos pestañas. Sin embargo, si tú, como programador, aprendes a utilizar estas pestañas, te convertirás en un usuario mucho más observador y exigente con respecto a las interfaces que te presenten otros programadores.

Entonces, para empezar a hablar y explicar un poco más sobre este tema, vamos a iniciar un nuevo tema.

Pestañas por defecto

Todo código creado enteramente en MQL5 podrá o no tener una ventana básica de configuración. Esta ventana no estará presente en todas las aplicaciones; en aplicaciones como scripts y servicios, podemos tenerla o no. Sin embargo, en indicadores y asesores expertos siempre se nos presentará con algunos elementos o, mejor dicho, pestañas por defecto. Estas no las crea el programador, sino que están definidas dentro del entorno de MetaTrader 5, lo que hace que tengamos un estándar de utilización y configuración de cualquier indicador o asesor experto.

Aunque, debido a una u otra cuestión, muchos programadores suelen añadir elementos de configuración que no serían necesarios. Esto se debe a que dichos elementos ya podrían ajustarse en las pestañas que se mostrarán por defecto al usuario. Pero la pregunta es: ¿sabes cómo acceder a los elementos definidos en las pestañas por defecto, mi querido lector? Y cuando hago esta pregunta, la hago como programador, no como usuario.

Cuando me refiero a pestañas por defecto, me refiero a lo que podemos ver en la secuencia de imágenes justo abajo.

Imagen 01

Imagen 02

Imagen 03

Imagen 04

Estas son las pestañas predeterminadas de un indicador. Como en este momento estamos enfocados en entender y aprender cómo funcionan los eventos en un indicador, precisamente por ser más sencillo, debemos aprender todo lo posible sobre él antes de pasar a cosas más complicadas. No obstante, este sistema de pestañas predeterminadas es bastante interesante y está muy bien pensado, ya que sirve perfectamente para diversos casos. De hecho, en la mayoría de los casos no es necesario implementar ningún tipo de entrada adicional. Pero, entonces, ¿por qué muchos programadores crean entradas adicionales? El motivo es que esto se vuelve necesario cuando este esquema por defecto, proporcionado por MetaTrader 5, no es capaz de cubrir nuestras necesidades. Sin embargo, antes de empezar a añadir cosas sin ton ni son, es mejor entender primero cómo utilizar estas pestañas para mantener tu aplicación dentro del estándar de MetaTrader 5.

Básicamente, la única pestaña que necesitamos manipular, si es que sientes la necesidad de hacerlo, es la que se ve en la imagen 01. Esto se debe a que en esta pestaña podemos añadir elementos para hacer las cosas más representativas en términos de indicar el objetivo de esa aplicación. Hacerlo es muy sencillo. Aunque, como aquí estamos y nos mantendremos enfocados únicamente en la parte didáctica, no voy a añadir elementos a esta pestaña. De todas formas, mi querido lector, debes pensar en cómo trabajar en esta primera pestaña, sobre todo si quieres poner tus aplicaciones a disposición.

Pues bien, para añadir o modificar esta pestaña, que se ve en la imagen 01, necesitamos indicar al compilador qué debe colocar en ella. Para ello, utilizaremos una directiva de compilación. Dicha directiva se utiliza como #property. Esta directiva nos permite definir una serie de cosas, desde la versión de la aplicación hasta un enlace a un lugar específico de la web. Para más detalles, revisa la documentación. Seguramente ya hayas visto esta directiva aplicada en todos mis códigos de los artículos. Básicamente, la única que defino por defecto es la propiedad de copyright. Vamos a ver cómo podemos definir otra para que te hagas una idea de lo que podemos hacer. Para ello, usaremos el código que aparece a continuación.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. #property version "1.0"
04. #property icon "Example.ico"
05. #property description "This is a demonstration application whose purpose is only didactic.\nIt is part of a sequence of articles published in the MQL5 community."
06. #property link "https://www.mql5.com/pt/articles/15794"
07. //+------------------------------------------------------------------+
08. int OnInit()
09. {
10.    return INIT_SUCCEEDED;
11. };
12. //+------------------------------------------------------------------+
13. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
14. {
15.    return rates_total;
16. };
17. //+------------------------------------------------------------------+

Código 01

Así, cuando se ejecute este código 01, verás que la imagen 01 se mostrará de forma diferente. Esto puede verse a continuación.

Imagen 05

Fíjate en que ahora tenemos un icono diferente al icono predeterminado y también una descripción del objetivo de la aplicación. Todo esto se define entre las líneas dos y cinco. Observa que necesitamos informar del directorio y del archivo de imagen que se utilizará como icono. En el anexo, dejaré las cosas de forma que puedas experimentar y entender cómo colocar un icono deseado. En este caso, como puedes observar en el código 01, el archivo del icono deberá estar en la carpeta donde se encuentra el código del indicador. No obstante, puedes colocarlo en otros lugares; basta con indicar la ubicación para que el compilador consiga encontrar el archivo deseado.

Pero espera un momento. Falta una información: la que estamos declarando en la línea seis del código 01. ¿Dónde ha ido a parar? Bien, en realidad, esta información, que antes se veía en la pestaña, ahora está asociada a otra información. Así, al pasar el mouse por encima de lo que sería la información de copyright, se puede ver lo que aparece en la imagen de abajo.

Imagen 06

De esta forma, podemos ver que toda la información está presente, como se puede observar en la imagen 06. Si hacemos clic en el punto que originó el enlace, se abrirá el navegador y nos dirigirá al lugar indicado en la línea seis del código 01. Como la mayor parte del tiempo imagino que, querido lector, estés creando algo para uso personal, puedes ignorar estas cosas, ya que no es necesario implementarlas. Aunque existen casos en los que necesitamos decirle al compilador cómo debe generarse el código, o, mejor dicho —ya que esta frase tal vez haya quedado confusa— existen circunstancias especiales en las que, incluso usando un código para nuestro uso personal, necesitamos configurar estas propiedades de compilación.

Uno de estos casos es, precisamente, cuando estamos creando un indicador cuyo objetivo es trazar algo en el gráfico. Sin embargo, es posible que eches de menos explicaciones sobre las demás pestañas vistas al principio de este tema. Te pido, querido y estimado lector, que tengas un poco de calma y paciencia. Volveremos a ellas en breve. Pero ahora necesitamos hacer otra cosa para que esas pestañas puedan tener sentido.

Un indicador básico

Hasta ahora, lo único que hemos hecho ha sido generar mucha información e imprimirla en el terminal para poder visualizarla. Aunque, finalmente, ha llegado la hora de poder ver algo dibujado en el gráfico. Para que resulte más agradable y comprensible, voy a utilizar un gráfico con el estilo predeterminado de MetaTrader 5. Solo lo haré con fines demostrativos, pero puedes usar el gráfico con la configuración que mejor te convenga o que más te agrade.

De acuerdo. En los dos artículos anteriores, se explicó el funcionamiento de dos eventos básicos generados por MetaTrader 5: el evento Deinit y el evento Init. Ambos tenían como objetivo indicar a nuestra aplicación cómo debía comportarse. No obstante, todos los indicadores necesitan dos eventos: uno es el evento Init, que ya se explicó, y el otro es el evento Calculate.

Ahora, presta mucha atención, querido lector, porque esto es muy importante. La función OnCalculate capturará el evento Calculate, que deberá estar presente en el código del indicador. No obstante, tenemos dos versiones de esta misma función. Es decir, MQL5 nos ofrece la posibilidad de usar una función sobrecargada por defecto; una de ellas se muestra a continuación y la otra más abajo.

int  OnCalculate(
   const int        rates_total,       // price[] array size
   const int        prev_calculated,   // number of handled bars at the previous call
   const int        begin,             // index number in the price[] array meaningful data starts from
   const double&    price[]            // array of values for calculation
   );

int  OnCalculate(
   const int        rates_total,       // size of input time series
   const int        prev_calculated,   // number of handled bars at the previous call
   const datetime&  time[],            // Time array
   const double&    open[],            // Open array
   const double&    high[],            // High array
   const double&    low[],             // Low array
   const double&    close[],           // Close array
   const long&      tick_volume[],     // Tick Volume array
   const long&      volume[],          // Real Volume array
   const int&       spread[]           // Spread array
   );

Pero, ¿por qué los desarrolladores de MQL5 hicieron esto? Creo que el motivo es hacer que el indicador se ejecute de manera más eficiente y consistente. Esto se debe a que existen diversas maneras de calcular algo, sobre todo si tenemos en cuenta que la mayor parte del tiempo un indicador estará calculando un promedio de valores. Así pues, los desarrolladores, al ver que podrían mejorar el rendimiento de la plataforma MetaTrader 5, decidieron permitir que algunos de estos cálculos no NECESITARAN ser realizados por el indicador, ya que la propia plataforma podría indicarnos el resultado de antemano. Tal vez ahora no tenga mucho sentido para ti, pero te aseguro que, conforme vayas practicando y estudiando, te darás cuenta de que tiene bastante sentido.

Pero entonces, ¿qué versión sobrecargada debería utilizar? La respuesta es: depende. No se trata de que necesites usar una u otra versión en detrimento de la otra. Ambas versiones hacen básicamente lo mismo: reciben el evento Calculate. Y listo. Lo que sucederá a partir de ahí dependerá de lo que planees y necesites hacer.

Aunque, existe un detalle curioso que debo confesar que fue una buena mejora de los desarrolladores de la plataforma. Dependiendo de si estás usando una u otra versión de OnCalculate, el usuario tendrá acceso o no a la pestaña que se muestra en la imagen 02. ¿Eh? ¿Cómo es eso? Si buscas ver artículos con imágenes, animaciones o vídeos de versiones antiguas de MetaTrader 5 en funcionamiento, notarás que la pestaña de la figura 02 aparece prácticamente siempre, incluso cuando es completamente innecesaria.

Sin embargo, en algún momento, esto dejó de existir. Si utilizas la versión con menos argumentos, la pestaña de la figura 02 estará disponible. Si usas la versión con más argumentos, esa pestaña no estará disponible. Por eso dije que las cosas se explicarían en su debido momento. Si se hubiera mencionado en aquel momento, no tendría ningún sentido. Pero ahora ya lo tendrá, y aún más cuando implementemos algún tipo de indicador.

Para empezar, crearemos uno muy sencillo, en el que prácticamente todo lo hará y creará MetaTrader 5. Nosotros, como programadores, haremos lo mínimo necesario para que funcione y para que todo quede lo más didáctico posible. Lo haremos por etapas. Aunque el código en sí sea muy sencillo de entender y de hacer, si lo hacemos en pequeñas etapas, todos, incluso los principiantes con un nivel básico, podrán seguirlo, siempre y cuando estén estudiando estos artículos.

Nuestro código comienza de la siguiente manera:

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. int OnInit()
05. {
06.    return INIT_SUCCEEDED;
07. };
08. //+------------------------------------------------------------------+
09. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
10. {
11.    return rates_total;
12. };
13. //+------------------------------------------------------------------+

Código 02

Observa que todavía no se ha hecho nada. El código solo contiene lo básico para que el compilador sepa cómo crear la aplicación deseada; es decir, un indicador que mostrará todas las pestañas como se explicó al principio de este artículo. Lo siguiente que haremos será describir nuestro indicador. Para ello, debemos indicarle al compilador qué es lo que debe crear. Hay dos formas de hacerlo: una dinámica, que es mucho más complicada y no se explicará en este momento, y otra estática, que es considerablemente más simple y directa. Es la ideal para pequeños códigos y está enfocada para quienes estén comenzando o simplemente quieran crear un indicador simple, rápido y práctico. Para ello, modificaremos el código 02 para obtener la versión que se muestra justo debajo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. #property indicator_type1           DRAW_LINE
05. #property indicator_color1          clrBlack
06. //+------------------------------------------------------------------+
07. int OnInit()
08. {
09.    return INIT_SUCCEEDED;
10. };
11. //+------------------------------------------------------------------+
12. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
13. {
14.    return rates_total;
15. };
16. //+------------------------------------------------------------------+

Código 03

Este es el segundo paso que necesitamos dar. Aunque la declaración de la línea cinco se debe a un pequeño error que aún persiste en el uso del sistema por defecto de MetaTrader 5. Sin esta línea, NO PODRÁS CAMBIAR EL COLOR del trazado del indicador, incluso siendo un indicador muy sencillo. Sin embargo, la declaración más importante es la que se hace en la línea cuatro. En esta línea, especificamos qué tipo de cosa queremos que se trace en el gráfico. En este caso, será una línea de precio. ¿Pero qué tipo de precio? ¿Cuáles serán las definiciones y propiedades de esta línea que se trazará? Paciencia, querido lector, ya llegaremos a este punto. Ten un poco de paciencia.

Una vez definido el tipo de indicador que se va a crear, hay que definir algunas otras características del mismo. Para ello, necesitamos consultar la documentación de MQL5 para saber cómo declarar los próximos puntos. Entonces, volvemos a la documentación y buscamos el término #property para encontrar información relacionada con lo que se está declarando en la línea cuatro, es decir, el tipo de indicador. Al buscar esta información, veremos algo que se destaca en la imagen de abajo.

Imagen 07

Este punto, que se muestra en la imagen 07, es muy importante para nosotros, ya que, sin él, no podremos indicar a MetaTrader 5 cómo se mostrará el indicador. Así, buscamos la enumeración ENUM_DRAW_TYPE. Al buscarla en la documentación, veremos una tabla como la que se muestra a continuación.

Imagen 08

La información que necesitamos es precisamente la que está marcada en verde en la imagen 08. Es decir, necesitamos un buffer para datos. Cada tipo de indicador necesita cosas diferentes. Como el que estamos creando es muy simple, solo necesitaremos un buffer. Con esta información, podemos volver al código 03 y añadirle algunas cosas más. Sin embargo, antes de hacerlo, necesitamos más información. Tiene que ver con la cantidad de elementos que el indicador necesitará dibujar en la pantalla. Para encontrarla, debemos buscar dentro de la propiedad #property. Se muestra justo debajo.

Imagen 09

Para obtener esta segunda información, nos basaremos en la misma tabla. Ahora, el valor que necesitaremos utilizar es la suma de estos dos valores mostrados en la imagen 10:

Imagen 10

Con toda esta información, podemos volver al código 03 y añadirle algunas cosas más. El código queda como se muestra a continuación.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. #property indicator_type1           DRAW_LINE
05. #property indicator_color1          clrBlack
06. //+----------------+
07. #property indicator_buffers         1
08. #property indicator_plots           1
09. //+------------------------------------------------------------------+
10. int OnInit()
11. {
12.    return INIT_SUCCEEDED;
13. };
14. //+------------------------------------------------------------------+
15. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
16. {
17.    return rates_total;
18. };
19. //+------------------------------------------------------------------+

Código 04

Al mirar este código 04, vemos en la línea siete la declaración que buscábamos y que encontramos en la imagen 08. En la línea ocho tenemos la indicación de otra información que es igual a la suma de los valores de la imagen 10. Con esto, ya estamos preparados para hacer que el indicador sea funcional. El último paso se muestra justo abajo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. #property indicator_type1           DRAW_LINE
05. #property indicator_color1          clrBlack
06. //+----------------+
07. #property indicator_buffers         1
08. #property indicator_plots           1
09. //+----------------+
10. double   gl_buffer[];
11. //+------------------------------------------------------------------+
12. int OnInit()
13. {
14.    SetIndexBuffer(0, gl_buffer, INDICATOR_DATA);
15. 
16.    return INIT_SUCCEEDED;
17. };
18. //+------------------------------------------------------------------+
19. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
20. {
21.    for (int c = prev_calculated; c < rates_total; c++)
22.       gl_buffer[c] = price[c];
23. 
24.    return rates_total;
25. };
26. //+------------------------------------------------------------------+

Código 05

Y ahí lo tienes, querido lector: un indicador completo y totalmente funcional en el que podemos pedirle que muestre cualquier tipo de información que MetaTrader 5 pueda ofrecernos, y lo hará perfectamente. Pero espera un momento, ¿cómo es posible? Ya he visto códigos de otros indicadores y tienen muchas más cosas. Esto no puede ser correcto. Ya he intentado crear varios indicadores y todos tienen muchas más cosas que esto que estás presentando. No creo que esto funcione de verdad. Quiero verlo, o mejor dicho, voy a probar para ver si esto funciona de verdad.

Bien, entiendo tu sorpresa, querido lector. Esto se debe a que cualquier código de indicador que llegues a observar tendrá muchas más cosas de las que estamos haciendo aquí. Pero, para demostrarte que este código funciona, vamos a ver algunas animaciones.

Animación 01

En esta animación 01, estoy mostrando cómo colocar el indicador y luego cambiar su color. Observa que es bastante simple e intuitivo.

Animación 02

En esta animación 02, se muestra cómo podemos modificar el estilo de línea del indicador. Nuevamente, algo muy intuitivo.

Animación 03

En esta animación 03, podemos ver cómo modificar el grosor de la línea que utilizará el indicador. En este caso, sería bueno que MetaTrader 5 pudiera utilizar estilos diferentes en diferentes grosores. De momento, hasta que los desarrolladores implementen esta opción, tendremos que adaptarnos a las condiciones actuales de MetaTrader 5.

Animación 04

Finalmente, en esta animación 04, podemos ver cómo se cambia el tipo de cálculo que se realizará en el indicador. Como puedes ver, es bastante simple, claro y directo, y no afecta a la forma de trabajar con el indicador. Quedó pendiente la cuestión de mostrar cómo funciona la pestaña vista en la figura 04, pero como este tipo de cosas es muy intuitiva y fácil de entender, basta con que tengas curiosidad y pruebes a utilizar dicha pestaña.

No veo necesidad de explicar esto aquí, ya que dicha pestaña solo se utiliza para configurar un entorno operativo. Rara vez un operador principiante intentará manipular esta pestaña. Pero, como programador, necesitas entender cómo funciona esta pestaña y cómo puedes implementarla en código. Sí, es posible configurar el funcionamiento del indicador sin necesidad de tocar esta pestaña; para ello, se utiliza MQL5 puro. Pero esto se verá más adelante, en un momento más oportuno.

Ahora que ya hemos visto cómo funciona el código, veamos rápidamente lo que se ha añadido en el último paso de la implementación. Lo que se explica aquí se abordará luego de forma un poco más avanzada. No obstante, es necesario que empieces a entender desde el principio por qué y cómo necesitamos estas líneas implementadas en el último paso, empezando por la línea 10.

Normalmente, no es aconsejable utilizar variables globales, como ya se explicó en los primeros artículos de esta serie. Sin embargo, la variable declarada en la línea 10 es un caso especial. En este caso, realmente necesitamos una variable global, ya que es necesaria para diversas cosas que veremos más adelante. No obstante, en este momento, lo que necesitas entender, querido lector, es que esta variable contendrá los datos que se trazarán en el gráfico, creando así el indicador que puedes ver en las animaciones.

Para ello, debemos indicarle a MetaTrader 5 CUÁL ES LA VARIABLE que debe utilizar, ya que en un código real pueden declararse diversas variables. Este tipo de información se proporciona utilizando lo que se ve en la línea 14. Básicamente, eso es todo. Una vez hecho esto, podemos comenzar a capturar el evento Calculate y utilizar los datos que MetaTrader 5 nos proporcionará para asignar valores a la variable declarada en la línea 10. 

Hacer esto no es complicado; de hecho, la mayor parte del tiempo es bastante simple. Todo lo que necesitamos hacer es calcular un valor y asignarlo a una posición concreta dentro del array declarado en la línea 10. Ahora presta atención, querido lector. Cuando se explicó el tema de los arrays, se dijo que existen dos tipos: los dinámicos y los estáticos. No obstante, TODO ARRAY que se vaya a usar para almacenar datos con fines de trazado en un indicador debe ser obligatoriamente dinámico. No obstante, NO DEBES asignarle memoria. Será el propio MetaTrader 5 quien la asignará conforme sea necesario. Por esta razón, podemos utilizar el código de la línea 22. En la línea 14 indicamos que esa variable se usará para almacenar datos referentes al indicador que se trazará. Así, MetaTrader 5 pasará a asumir el control total sobre la memoria que necesite asignarse.

Ahora bien, también hay otro aspecto importante. Lo ideal y deseable es que toda aplicación que se vaya a ejecutar en MetaTrader 5 sea lo más eficiente posible. Esto es para evitar consumir mucho tiempo y también para que la plataforma se mantenga estable. Por esta razón, observa cómo se está creando este bucle en la línea 21. Quizás tengas la primera impresión de que, cada vez que se captura un evento Calculate, se leen todos los datos del array price desde el principio hasta el final. Sin embargo, no es exactamente así como suceden las cosas, al menos no debería ser así.

Básicamente, y a nivel interno, MetaTrader 5 almacena algunos valores internos para controlar lo que están haciendo las aplicaciones. Entonces, la primera vez que el evento Calculate sea capturado por nuestro indicador, el valor de rates_total nos indicará la cantidad de datos presentes en el array price. El valor de prev_calculated podrá ser igual a cero o no, pero, con toda certeza, apuntará al primer dato de la serie. Esto puede cambiarse, como veremos más adelante. Por ahora, solo necesitas entender lo que se ha dicho; esta condición solo se cumplirá la primera vez, siempre que tu código esté debidamente implementado y siga las reglas.

En la próxima llamada, el valor de prev_calculated podrá ser igual o no al de rates_total. Si es igual, significa que no hubo ningún cambio significativo. Si es menor, se ejecutará el bucle para actualizar el valor que se trazará en el gráfico.

Por tanto, si implementas correctamente el código, la primera ejecución será lenta. No obstante, en todas las demás capturas del evento Calculate, se ejecutará el mínimo de operaciones, por lo que la plataforma podrá realizar cualquier tipo de análisis y mostrar el resultado al operador de forma muy rápida.

Vale, pero no entendí una cosa: ¿cómo podría producirse un evento Calculate si los valores de prev_calculated y rates_total fueran iguales? ¿No sería eso una pérdida de tiempo, ya que el bucle de la línea 21 no llevaría a cabo ninguna acción? Sí, mi querido lector, esto es verdad. Aunque MetaTrader 5 NO disparará un evento Calculate así porque sí. Solo lo disparará si hay un cambio en la cotización del símbolo. Por esta razón, en momentos de mucha volatilidad en el mercado, se producirá una verdadera avalancha de eventos. Si tu código está mal optimizado, la plataforma acabará volviéndose lenta. Pero la culpa no es de la plataforma, sino de una aplicación mal optimizada que estará consumiendo tiempo y recursos.

Consideraciones finales

Muy bien, en este artículo crearemos nuestro primer indicador totalmente práctico y funcional. El objetivo no es mostrar cómo se crea una aplicación, sino ayudarte a entender cómo puedes desarrollar tus propias ideas de forma segura, simple y práctica. El objetivo es que puedas ponerlas en práctica de forma segura, simple y práctica.

Como este tema necesita ser muy bien asimilado y estudiado, no me extenderé más de lo necesario, ya que haría que el material fuera mucho más denso y complejo de lo que considero necesario y posible de estudiar con calma. En el anexo encontrarás dos de los códigos vistos aquí. Podrás utilizarlos para comprender el paso a paso mostrado en el artículo.

En el próximo artículo, continuaremos donde este se está finalizando, ya que aún queda por tratar la segunda forma de declaración de la función OnCalculate.