Câmbio de moedas

A Julia é uma linguagem de uso geral que pode ser usada na maioria das tarefas de programação. Na prática, porém, as principais utilizações tendem a ser na engenharia e na ciência. Os cálculos numéricos rápidos, versáteis e sofisticados estão no centro da sua conceção.

Números inteiros

Um número inteiro é um número "redondo", sem vírgula decimal.

No conceito Básicos, vimos que é possível atribuir um valor inteiro a uma variável sem especificar o tipo.

Para facilitar a leitura, podem usar-se underscores como separador de algarismos. O compilador ignora-os.

julia> x = 3
3

julia> typeof(x)
Int64

julia> large_number = 1_234_567_890
1234567890

Vírgula flutuante

Não é surpresa que os números de vírgula flutuante tenham uma vírgula decimal, e uma parte fracionária depois da vírgula.

julia> f = 3.45
3.45

julia> typeof(f)
Float64

Claro que a notação científica é suportada.

julia> avogadro = 6.02e23
6.02e23

Os valores máximo e mínimo podem surpreender-te:

julia> typemax(Float64)
Inf

julia> typemin(Float64)
-Inf

O infinito é um valor válido!

Operadores aritméticos

Como vimos no conceito Básicos, os operadores aritméticos funcionam, na maioria dos casos, como na aritmética normal, aquela que aprendemos em criança. Repara que a exponenciação usa ^, e não ** (ambos são comuns noutras linguagens).

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 entanto, há alguns pormenores específicos da Julia que vale a pena discutir.

Multiplicação

julia> x = 4.2
4.2

julia> 2 * x
8.4

julia> 2x
8.4

julia> 2.4x
10.08

Isso pode ser surpreendente.

É sempre possível usar * como operador infixo, como na maioria das outras linguagens de programação.

No entanto, a Julia foi criada por pessoas que acreditam que o código deve parecer-se o mais possível com equações matemáticas.

Como os nomes de variáveis têm de começar por uma letra, colocar um número (inteiro ou de vírgula flutuante) antes do nome é tratado como multiplicação implícita.

Por exemplo, se quisermos a área da superfície de uma esfera, em vez de 4 * pi * r * r podemos fazer isto:

julia> surface(r) = 4π * r^2
surface (generic function with 1 method)

julia> surface(3)
113.09733552923255

Embora o π seja uma constante incorporada, também é uma letra (grega). Por isso, o analisador sintático continua a precisar de um * explícito para separar o π do r.

Divisão

Usar / como operador infixo dá sempre um resultado de vírgula flutuante, mesmo para valores de entrada inteiros.

Para a divisão inteira, há mais opções.

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

A função div() serve para a divisão inteira e trunca o resultado em direção ao zero: para baixo nos números positivos, para cima nos negativos.

Como sinónimo, podemos usar o operador infixo ÷, mais uma vez para o tornar mais matemático. Se estiveres a usar um editor com suporte para Julia, escreve \div e a seguir prime a tecla <Tab>.

O operador // está para lá do âmbito deste conceito. Por agora, basta dizer que o resultado de // é um número "racional", aquilo a que a maioria das pessoas chama fração.

Conversão de tipos numéricos

Isto pode acontecer automaticamente muitas vezes:

julia> x = 2 + 3.5
5.5

julia> typeof(x)
Float64

Somámos um Int64 a um Float64 e obtivemos um resultado Float64.

Na verdade, o número inteiro foi convertido silenciosamente num Float64 antes de se fazer a adição.

As conversões de vírgula flutuante para inteiro são inevitavelmente mais complicadas. O que queres fazer com o que vem depois da vírgula decimal?

• A função round() converte para o número inteiro mais próximo, com os empates, como 4.5, a arredondar para o número inteiro par mais próximo.
• floor() arredonda para baixo, ceil() arredonda para cima, trunc() arredonda em direção ao zero.
• Tentar converter diretamente, por exemplo com Int32(), dá origem a um InexactError.

No entanto, por predefinição, estas funções não devolvem o tipo inteiro que poderias querer. É possível especificar o tipo de resultado pretendido.

julia> round(4.5)
4.0

julia> ceil(Int, 4.3)
5

Também é possível arredondar para um número especificado de algarismos depois da vírgula decimal, através da palavra-chave digits.

julia> round(π, digits=10)
3.1415926536

Divisão por zero

Certamente que isto dá logo um erro? Na verdade, a situação não é assim tão simples.

A divisão inteira com ÷ ou // dá um erro, como seria de esperar.

A divisão de vírgula flutuante com / segue uma abordagem que se pode considerar de engenharia, em vez da abordagem padrão da informática:

julia> 2 / 0
Inf

julia> 0 / 0
NaN

Como vimos numa secção anterior, o infinito é um número de vírgula flutuante válido na Julia, representado por Inf.

Quando o numerador também é zero, o resultado é matematicamente indefinido. A Julia trata-o então como "não é um número", representado por NaN.