Capítulo 1. Primeros pasos

Veamos ahora un primer ejemplo práctico de Julia, con un programa sencillo para calcular el día de la semana en el que cae cualquier fecha del calendario Gregoriano, usando el algoritmo de Gauss tal como está publicado por Bernt Schwerdtfeger.^[1] Se trata de un algoritmo simple, consistente en los siguientes pasos:

1. Si el número del mes (m) es igual o mayor que 3 (de marzo en adelante), el número del año (y) se descompone en el número del siglo (c, correspondiente a las centenas) y el resto (g). En el caso de enero o febrero (m < 3) se hace la misma descomposición para y-1.
2. Se escoge un número e en función del número del mes (de 1 a 12), según la tabla 1 que se presenta a continuación.
3. Se escoge un número f según el número del siglo (tabla 2), en un ciclo de 4 siglos (el ciclo de años bisiestos se repite cada 400 años).
4. El día de la semana viene determinado por el resto de la división entera entre x y 7, siendo x = d + e + f + g + ⌊g/4⌋ (el último sumando es el cociente de la división entera entre g y 4).

Tabla 1: código de mes

Tabla 2: código de siglo

Este algoritmo se puede implementar en Julia con la siguiente función:

"""
Cálculo del día de la semana.
La función devuelve una cadena de texto con el día de la semana que corresponde
a los números de día, mes y año introducidos como los argumentos numéricos
`d`, `m`, `y`, respectivamente.
"""
function gauss_diasemana(d, m, y)
    #=
    Enero y febrero (m=1, m=2) se tratan como el año anterior
    en torno a los años bisiestos
    =#
    if m < 3
        y = y - 1
    end
    # Dividir el año entre centenas (c) y el resto (g)
    c = div(y, 100)
    g = rem(y, 100)
    # Definir e y f en función del mes (de 1 a 12) y el siglo
    # (en ciclos de 400 años --- 4 siglos)
    earray = [0,3,2,5,0,3,5,1,4,6,2,4]
    farray = [0,5,3,1]
    e = earray[m]
    f = farray[mod(c,4) + 1]
    # Seleccionar el día de la semana en función del cálculo de Gauss
    warray = ["domingo","lunes","martes","miércoles",
        "jueves","viernes","sábado"]
    w = rem(d + e + f + g + div(g, 4), 7)
    return(warray[w+1])
end

Supongamos que el código mostrado arriba está guardado en un archivo llamado calc_diasemana.jl (el nombre del archivo es arbitrario, y puede ser cualquier nombre aceptado por el sistema operativo). El programa consiste en una sola función con tres argumentos (los números del día, el mes y el año), basada en unas pocas divisiones enteras (definidas en la función div) y el cálculo de "restos" de dichas divisiones (rem, del inglés remainder),^[2] más la selección de unos valores a partir de los resultados intermedios y unas listas predefinidas.

Este programa se puede cargar usando la función include en el REPL, como sigue:

julia> include("calc_diasemana.jl")

El resultado posiblemente sea algo decepcionante, porque lo único que se ha hecho es definir una función, que por sí misma no da ningún resultado. Por otro lado, lo más probable es que al introducir esa línea sin más, ni siquiera se obtenga ningún resultado, sino un error debido a que no se encuentra el archivo de código. Para asegurarse de que Julia encuentra el archivo hay varias alternativas:

• Copiar el archivo de código calc_diasemana.jl al directorio de trabajo de Julia. La ruta de ese directorio se puede obtener con la función pwd() –sin ningún argumento–.
• Cambiar el directorio de trabajo al lugar que contiene el archivo. El cambio de directorio se hace con el comando cd(directorio), donde directorio ha de ser la ruta de destino.
• Introducir la ruta completa del archivo de código en la llamada a include. Esta se puede escribir literalmente, o si el directorio que contiene el archivo está definido en una variable (supongamos que esta variable se llama directorio), la ruta se puede componer con la función joinpath. Es decir, la expresión anterior sería include(joinpath(directorio, "calc_diasemana.jl")).

Una vez se ha conseguido cargar el archivo que define la función, esta ya se puede usar para obtener un resultado de verdad. Por ejemplo, para conocer en qué día de la semana cayó el 11 de agosto de 2018, la fecha en la que se publicó la version 1 de Julia:

julia> gauss_diasemana(11, 8, 2018)
"sábado"

Lo que se hace "en un día cualquiera" usando Julia es esencialmente este modelo de rutina, con funciones más complicadas y muchas más operaciones interactivas, explorando resultados, corrigiendo argumentos y repitiendo operaciones, claro está.

Durante una sesión de trabajo habitual, los datos generados suelen guardarse en variables para usarlas en pasos posteriores. Por ejemplo, podríamos definir las variables día, mes y año para recoger los números que luego utilizamos en la función gauss_diasemana:

julia> día = 11;

julia> mes = 8;

julia> año = 2018;

julia> diasemana = gauss_diasemana(día, mes, año)
"sábado"

Sintaxis básica

Para escribir un programa en Julia o cualquier otro lenguaje de programación hay que seguir una serie de reglas sintácticas, la mayoría de las cuales en realidad no es necesario explicar, ya que son reglas de escritura lógicas e intuitivas, o se desprenden directamente de la lectura de ejemplos. A continuación se mencionan algunos detalles básicos que se pueden observar en el anterior ejemplo del algoritmo de Gauss:

• Cada operación se escribe normalmente en una línea distinta, aunque es posible "partir" las expresiones en varias líneas. Si una línea acaba con una expresión incompleta se asume que continúa en la siguiente, como ocurre en la definición de la variable warray con los nombres de los días de la semana:

warray = ["domingo","lunes","martes","miércoles",
    "jueves","viernes","sábado"]

• Todo el texto que sigue al símbolo # hasta el final de la línea se considera un comentario, y no se ejecuta. También se pueden hacer bloques de comentarios que ocupen varias líneas, delimitados por #= al principio y =# al final, como se ha hecho al comienzo de la función.

• Las expresiones más habituales son las del tipo a = f(b), como c = div(y, 100), donde a es un nombre de variable, f el nombre de una función, y b el número, cadena de texto u otro tipo de argumento sobre el que opera esa función, o bien el nombre de la variable a la que se le ha asignado el valor de ese argumento. (La función también puede aceptar varios argumentos de entrada, como ocurre con div, o tener varias salidas, que se presentan como variables separadas por comas.)

• También es habitual encontrarse expresiones del tipo a = f[b], p.ej. en e = earray[m], con corchetes en lugar de paréntesis. En esos casos f no es una función sino un vector, matriz u otra colección de datos, y b es el índice o clave que identifica la parte de su contenido que se asignará a la variable a.

• Los nombres de variables, funciones, etc. pueden estar formados por cualquier combinación de letras y números, más guiones bajos, exceptuando nombres que comiencen por números y las palabras clave del lenguaje (como for, if, function, end, etc.). Además, también se admiten nombres con caracteres Unicode más allá del ASCII básico (letras acentuadas, griegas, etc.), así como el signo de exclamación (!) en posición no inicial, aunque conviene usarlos con mesura: emplear caracteres extendidos aumenta el riesgo de problemas de portabilidad de los programas, y la exclamación se suele resevar para el nombre de cierto tipo de funciones (las que modifican sus argumentos de entrada).

• Se puede trabajar con muchos tipos de variables. En este ejemplo se manejan números enteros (0, 1, etc.) y también cadenas de texto, que se escriben entrecomilladas ("lunes", "martes", etc.). En capítulos posteriores se verán otros tipos. Las distintas variables empleadas en un programa pueden hacer referencia a cualquier tipo de variable, e incluso pueden cambiar de tipo a lo largo del programa (aunque es mejor ser consistente en la nomenclatura).

• Los programas suelen tener diversos bloques de código anidados. La función gauss_diasemana es en sí un bloque, dentro del cual hay un bloque condicional (el que comienza por if m < 3). Los bloques de código se delimitan cerrándolos con la palabra clave end, y se recomienda indentar las líneas interiores al código para hacerlo más legible, aunque el programa funcionaría igualmente si no se hace. Otros bloques de código habituales son los bucles for y while. Para más detalles sobre los distintos tipos de bloques, véase el capítulo 3 sobre funciones y estructuras de control.

• En general los espacios son irrelevantes: con contadas excepciones, puede usarse un espacio, varios o ninguno tanto al principio como al final de las líneas, o entre nombres de variables o funciones y símbolos delimitadores varios (operadores matemáticos, signos de puntuación, paréntesis...).

Manejando el espacio de trabajo

Al iniciar el REPL de Julia se crea un workspace o "espacio de trabajo", en el que se registran las distintas variables que se crean o modifican con cada operación. En una sesión de trabajo larga es fácil perder la pista de las variables que se han creado o a su contenido; la función varinfo sirve para observar esa información:

julia> varinfo()
name                    size summary                
–––––––––––––––– ––––––––––– –––––––––––––––––––––––
Base                         Module                 
Core                         Module                 
InteractiveUtils 163.926 KiB Module                 
Main                         Module                 
ans                 15 bytes String                 
año                  8 bytes Int64                  
diasemana           15 bytes String                 
día                  8 bytes Int64                  
gauss_diasemana      0 bytes typeof(gauss_diasemana)
mes                  8 bytes Int64                  

En este ejemplo podemos ver las variables día, mes, año y diasemana que hemos generado, más la función gauss_diasemana, y cuatro elementos más descritos como Module, que forman parte de la sesión de trabajo, aunque normalmente no hace falta interactuar directamente con ellos. Por contra, las variables creadas durante la ejecución de gauss_diasemana (c, g, etc.) no se recogen, ya que son variables "locales" a la función, a las que no se puede acceder desde el entorno del REPL, y que se puede considerar que se destruyen al terminar la función.

Esta lista puede llegar a contener muchas variables, creadas en algún momento de la sesión pero que no se necesitan más, y que incluso pueden molestar porque ocupan grandes cantidades de memoria o interfieren en cálculos posteriores. Una forma de librarse de ellas es "vaciarlas" de contenido, del siguiente modo:

julia> x = nothing

Esta operación asigna a la variable x un objeto que "no es nada", y su valor anterior, si no es utilizado por ninguna otra variable, será eliminado automáticamente para liberar memoria cuando haga falta. El nombre de la variable aún seguirá presente en la sesión de trabajo, porque borrar todo rastro de las variables creadas puede dar lugar a problemas e inestabilidades no previstas, según el entorno en el que se esté trabajando. (Para limpiar completamente el espacio de trabajo, el único modo es terminar la sesión de Julia y comenzar una nueva.)

Módulos y paquetes

using Statistics