Julia es un lenguaje de propósito general que puede usarse para la mayoría de las tareas de programación.
En la práctica, sin embargo, sus principales casos de uso suelen darse en la ingeniería y la ciencia.
Los cálculos numéricos rápidos, versátiles y sofisticados son fundamentales en su diseño.
Números enteros
Un número entero es un número «redondo», sin parte decimal.
En el concepto Fundamentos vimos que se puede asignar un valor entero a una variable sin especificar un tipo.
Por legibilidad, se pueden usar guiones bajos como separador de dígitos.
El compilador los ignora.
julia> x = 3
3
julia> typeof(x)
Int64
julia> large_number = 1_234_567_890
1234567890
Coma flotante
No sorprenderá que los números de coma flotante tengan una coma decimal y una parte fraccionaria después de la coma.
julia> f = 3.45
3.45
julia> typeof(f)
Float64
Por supuesto, se admite la notación científica.
julia> avogadro = 6.02e23
6.02e23
Los valores máximo y mínimo pueden sorprenderte:
julia> typemax(Float64)
Inf
julia> typemin(Float64)
-Inf
¡El infinito es un valor válido!
Operadores aritméticos
Como vimos en el concepto Fundamentos, los operadores aritméticos funcionan en su mayor parte igual que la aritmética estándar que se enseña a los niños.
Ten en cuenta que la exponenciación usa ^, no ** (ambos son habituales en otros lenguajes).
2 + 3 # 5 (addition)
2 - 3 # -1 (subtraction)
2 * 3 # 6 (multiplication)
8 / 2 # 4.0 (division)
8 % 3 # 2 (remainder)
2 ^ 3 # 8 (exponentiation)
No obstante, merece la pena comentar algunos detalles específicos de Julia.
Multiplicación
julia> x = 4.2
4.2
julia> 2 * x
8.4
julia> 2x
8.4
julia> 2.4x
10.08
Eso puede resultar sorprendente.
Siempre es posible usar * como operador infijo, como en la mayoría de los demás lenguajes.
Sin embargo, Julia está diseñada por personas que creen que el código debería parecerse lo máximo posible a las ecuaciones matemáticas.
Como los nombres de las variables deben empezar por una letra, anteponer un número (entero o de coma flotante) al nombre se interpreta como una multiplicación implícita.
Por ejemplo, si queremos el área de la superficie de una esfera, en lugar de 4 * pi * r * r podríamos hacer esto:
julia> surface(r) = 4π * r^2
surface (generic function with 1 method)
julia> surface(3)
113.09733552923255
Aunque π es una constante integrada, también es una letra (griega).
Por eso el analizador sintáctico sigue necesitando un * explícito para separar π de r.
División
Usar / como operador infijo siempre da como resultado un número de coma flotante, incluso con entradas enteras.
Para la división entera hay más opciones.
julia> 10 / 3 # floating-point division
3.3333333333333335
julia> div(10, 3) # integer division
3
julia> 10 ÷ 3 # synonym for div()
3
julia> 10 // 3 # rational number (fraction)
10//3
La función div() sirve para la división entera, y su resultado se trunca hacia cero: hacia abajo para los números positivos y hacia arriba para los negativos.
Como sinónimo, podemos usar el operador infijo ÷, de nuevo con la intención de que parezca más matemático.
Si usas un editor que entienda Julia, escribe \div y luego pulsa la tecla <Tab>.
El operador // queda fuera del alcance de este concepto.
Por ahora, basta con decir que el resultado de // es un número «racional», que la mayoría de la gente llama fracción.
Conversión de tipos numéricos
Esto a menudo ocurre de forma automática:
julia> x = 2 + 3.5
5.5
julia> typeof(x)
Float64
Hemos sumado un Int64 a un Float64 y el resultado ha sido un Float64.
De hecho, el entero se convirtió de forma silenciosa en un Float64 antes de hacer la suma.
Las conversiones de coma flotante a entero son inevitablemente más complicadas.
¿Qué quieres hacer con lo que haya después de la coma decimal?
- La función
round() convierte al número entero más próximo y, en los empates, como 4,5, redondea al número entero par más próximo.
-
floor() redondea hacia abajo, ceil() hacia arriba y trunc() hacia cero.
- Si intentas hacer una conversión directa, por ejemplo con
Int32(), fallará con un InexactError.
No obstante, de forma predeterminada estas funciones no devuelven el tipo entero que quizá esperabas.
Puedes especificar el tipo de salida que quieres.
julia> round(4.5)
4.0
julia> ceil(Int, 4.3)
5
También es posible redondear a un número concreto de dígitos después de la coma decimal con la palabra clave digits.
julia> round(π, digits=10)
3.1415926536
División por cero
¿Seguro que esto simplemente lanza un error?
En realidad, la situación no es tan sencilla.
La división entera con ÷ o // da lugar a un error, como cabría esperar.
La división de coma flotante con / adopta lo que podría considerarse un enfoque de ingeniería, en lugar del enfoque habitual de las ciencias de la computación:
julia> 2 / 0
Inf
julia> 0 / 0
NaN
Como vimos en una sección anterior, el infinito es un número de coma flotante válido en Julia y se representa con Inf.
Cuando el numerador también es cero, el resultado es matemáticamente indefinido.
En ese caso Julia lo trata como «no es un número», representado por NaN.
Ejercicio de aprendizaje
