Cambio de divisas

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 estar en la ingeniería y la ciencia. Los cálculos numéricos rápidos, versátiles y sofisticados son fundamentales en su diseño.

Enteros

Un entero es un número «exacto», sin punto decimal.

En el concepto Básicos, vimos que se puede asignar un valor entero a una variable sin especificar un tipo.

Para que sea más fácil de leer, 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

Punto flotante

No sorprenderá que los números de punto flotante tengan un punto decimal y una parte fraccionaria después del punto.

julia> f = 3.45
3.45

julia> typeof(f)
Float64

Por supuesto, la notación científica es compatible.

julia> avogadro = 6.02e23
6.02e23

Los valores máximo y mínimo pueden sorprender:

julia> typemax(Float64)
Inf

julia> typemin(Float64)
-Inf

¡El infinito es un valor válido!

Operadores aritméticos

Como se explicó en el concepto Básicos, los operadores aritméticos funcionan en su mayoría 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 comunes 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)

Sin embargo, vale 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 sorprender.

Siempre es posible usar * como operador infijo, como en la mayoría de los otros lenguajes de programación.

Sin embargo, Julia fue diseñado por personas que creen que el código debería parecerse lo más posible a las ecuaciones matemáticas.

Como los nombres de las variables deben empezar con una letra, anteponer un número (entero o de punto flotante) al nombre se trata 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 incorporada, también es una letra (griega). Por eso el analizador sintáctico todavía necesita un * explícito para separar π de r.

División

Usar / como operador infijo siempre da un resultado de punto flotante, incluso con números enteros.

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, con el resultado truncado hacia cero: hacia abajo para los números positivos, hacia arriba para los negativos.

Como sinónimo, podemos usar el operador infijo ÷, de nuevo con la intención de que se vea más matemático. Si usas un editor que entiende Julia, escríbelo como \div y luego presiona la tecla <Tab>.

El operador // está más allá 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 puede ocurrir automáticamente:

julia> x = 2 + 3.5
5.5

julia> typeof(x)
Float64

Sumamos un Int64 a un Float64 y obtuvimos un resultado Float64.

De hecho, el entero se convirtió silenciosamente en un Float64 antes de hacer la suma.

Las conversiones de punto flotante a entero son inevitablemente más complicadas. ¿Qué quieres hacer con lo que queda después del punto decimal?

• La función round() convierte al número entero más cercano; en los empates, como 4.5, redondea al número entero par más cercano.
• floor() redondea hacia abajo, ceil() hacia arriba y trunc() hacia cero.
• Intentar convertir directamente, por ejemplo con Int32(), fallará con un InexactError.

Sin embargo, por defecto estas funciones no devuelven el tipo entero que quizá querías. Se puede especificar el tipo de salida deseado.

julia> round(4.5)
4.0

julia> ceil(Int, 4.3)
5

También es posible redondear a un número específico de dígitos después del punto decimal con la palabra clave digits.

julia> round(π, digits=10)
3.1415926536

División por cero

¿Acaso esto no lanza simplemente un error? En realidad, la situación no es tan simple.

La división entera con ÷ o // dará como resultado un error, como era de esperar.

La división de punto flotante con / adopta lo que podría considerarse un enfoque de ingeniería, en lugar del enfoque estándar de las ciencias de la computación:

julia> 2 / 0
Inf

julia> 0 / 0
NaN

Como se explicó en una sección anterior, el infinito es un número de punto flotante válido en Julia, representado por Inf.

Cuando el numerador también es cero, el resultado es matemáticamente indefinido. Entonces Julia lo trata como «no es un número», representado por NaN.