Utilizar los tipos en Julia (8ª parte – ¡Hola Julia!)

Una de las características que posiblemente menos se destaque de Julia es que es un lenguaje con tipado de datos. Lo que nos permite indicarle al lenguaje que las variables solamente pueden ser de un tipo. Lo que hemos usado en una entrada anterior para sobrecargar los métodos y llamar a uno y otro en función del tipo de dato que nos llega. Pero esta es una característica, que, si la usamos correctamente, nos puede evitar errores en tiempo de ejecución porque llegue un dato de un tipo incorrecto. Por ejemplo, cuando llega una cadena de texto y esperábamos un valor numérico o, incluso, llega un real y el tipo debería de ser entero. Veamos en esta entrada cómo se pueden utilizar los tipos de datos en Julia para evitar algunos problemas habituales.

Definiendo las funciones que admite una función

Supongamos que queremos definir la función de probabilidad de una distribución binomial (función ya se puede enconar implementado paquete Distributions de Julia). Sabemos que esta función tiene dos parámetros, el primero es el número de ensayos y, por lo tanto, tiene que ser necesariamente un número entero. Por otro lado el segundo es la probabilidad de éxito, un número real que ha de estar comprendido entre 0 y 1. Además, el dominio de la función es sobre los datos enteros positivos. Un usuario despistado o una mala implementación del código puede hacer que intercambiemos los valores o sean introducidos de forma incorrecta.

Implementación básica de la función de probabilidad de una distribución binomial

Podemos implementar la función densidad de probabilidad de la distribución normal con el siguiente código

function binomialpdf(k, n, p)
    return binomial(n, k) * p^k * (1 - p)^(n - k)
end

En este caso si un usuario intenta calcular la función con un valor real de k nos aparecerá un error porque binomial no admite más que enteros. Pero si la función es más larga puede que el usuario no sepa lo que pasa. Así que una buena práctica puede ser hacer igual que en la liberia estándar de Julia, indicar los tipos de datos que nuestra función admite.

Así podemos indicar tanto que k como n son enteros y p es un valor real. Algo que es relativamente sencillo. Además, se puede indicar que el tipo de dato que va a devolver la función es Real, lo que nos dará un error si asignamos el resultado a una variable de tipo cadena de texto.

function binomialpdf(k::Integer, n::Integer, p::Real)::Real
    return binomial(n, k) * p^k * (1 - p)^(n - k)
end

Indicar el tipo en nuestra variable

Además de lo anterior también se le puede indicar el tipo a las variables que usemos en nuestras funciones. Pudiendo darnos cuenta de forma rápida si el tipo no es el correcto y, por lo tanto, hay un error en la codificación. Por ejemplo, al usar la siguiente función tendremos un error porque intentamos asignar un valor real a una variable entera. Incluso si el resultado de la función es 0 nos aparecerá el error.

function pdf(k::Integer, n::Integer, p::Real)::Real
    resultado::Integer = binomialpdf(k, n, p)
    return resultado
end

Algo que se puede solucionar simplemente indicando el tipo de dato correcto.

function pdf(k::Integer, n::Integer, p::Real)::Real
    resultado::Real = binomialpdf(k, n, p)
    return resultado
end

Conclusiones

En esta pequeña entrada hemos visto la utilidad de los tipos de datos en Julia. Una característica que no es muy usada, pero permite evitar algunos tipos de errores de en nuestros programas. Es una práctica que no exige mucho trabajo, y nos permite ahorrar tiempo al encontrar algunos problemas de una forma casi automática.

Julia es un lenguaje de programación de tipado dinámico, esto es, no realiza las comprobaciones de un lenguaje de tipado estático como es el caso de C/C++, Java, C# o Swift. Aunque el uso de los tipos nos ofrece algunas de las ventajas de estos lenguajes. Los programas de Julia se pueden ejecutar sin ninguna indicación acerca de los tipos de datos, lo que es muy cómodo en la fase de prototipado. Sin embargo incluir estas indicaciones de tipo puede aumentar el rendimiento al ayudar al compilador en la creación de un código más compacto y optimizado.