Câmbio de moedas

Julia é uma linguagem de propósito geral que pode ser usada na maioria das tarefas de programação. Na prática, porém, seus principais casos de uso tendem a estar na engenharia e na ciência. Cálculos numéricos rápidos, versáteis e sofisticados são centrais no seu projeto.

Números inteiros

Um número inteiro é um número "redondo", sem ponto decimal.

No conceito Básico, vimos que um valor inteiro pode ser atribuído a uma variável sem especificar um tipo.

Para facilitar a leitura, você pode usar sublinhados como separador de dígitos. O compilador os ignora.

julia> x = 3
3

julia> typeof(x)
Int64

julia> large_number = 1_234_567_890
1234567890

Ponto flutuante

Não é surpresa que números de ponto flutuante tenham um ponto decimal e uma parte fracionária depois do ponto.

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:

julia> typemax(Float64)
Inf

julia> typemin(Float64)
-Inf

O infinito é um valor válido!

Operadores aritméticos

Como vimos no conceito Básico, os operadores aritméticos funcionam quase da mesma forma que a aritmética padrão, como se ensina às crianças. Repare que a exponenciação usa ^, não ** (ambos são comuns em outras 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, vale a pena discutir alguns detalhes específicos da Julia.

Multiplicação

julia> x = 4.2
4.2

julia> 2 * x
8.4

julia> 2x
8.4

julia> 2.4x
10.08

Isso pode surpreender.

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

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

Como os nomes de variáveis devem começar com uma letra, colocar um número (inteiro ou de ponto 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 poderíamos fazer isto:

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

julia> surface(3)
113.09733552923255

Embora π seja uma constante embutida, ele também é uma letra (grega). Por isso, o parser ainda precisa de um * explícito para separar π de r.

Divisão

Usar / como operador infixo sempre dá um resultado de ponto flutuante, mesmo quando os valores são 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, com o resultado truncado em direção a zero: para baixo nos números positivos e para cima nos negativos.

Como sinônimo, podemos usar o operador infixo ÷, de novo com o objetivo de deixar tudo com cara mais matemática. Se você usa um editor que entende Julia, digite \div e depois aperte a tecla <Tab>.

O operador // está além do escopo deste conceito. Por enquanto, basta dizer que o resultado de // é um número "racional", aquilo que a maioria das pessoas chama de fração.

Conversão de tipos numéricos

Isso muitas vezes acontece automaticamente:

julia> x = 2 + 3.5
5.5

julia> typeof(x)
Float64

Somamos um Int64 com um Float64 e obtivemos um resultado Float64.

Na verdade, o inteiro foi convertido silenciosamente para Float64 antes de a soma ser feita.

As conversões de ponto flutuante para inteiro são inevitavelmente mais complicadas. O que você quer fazer com o que vem depois do ponto decimal?

• A função round() converte para o número inteiro mais próximo, e em empates como 4,5 arredonda para o número inteiro par mais próximo.
• floor() arredonda para baixo, ceil() arredonda para cima e trunc() arredonda em direção a zero.
• Tentar converter diretamente, por exemplo com Int32(), vai falhar com um InexactError.

No entanto, por padrão essas funções não retornam o tipo inteiro que você talvez quisesse. É possível especificar o tipo de saída desejado.

julia> round(4.5)
4.0

julia> ceil(Int, 4.3)
5

Também é possível arredondar para um número específico de dígitos depois do ponto decimal usando a palavra-chave digits.

julia> round(π, digits=10)
3.1415926536

Divisão por zero

Com certeza isso só gera um erro, não é? Na verdade, a situação não é tão simples assim.

A divisão inteira com ÷ ou // resulta em um erro, como você provavelmente espera.

A divisão de ponto flutuante com / adota o que se poderia chamar de abordagem de engenharia, em vez da abordagem padrão da ciência da computação:

julia> 2 / 0
Inf

julia> 0 / 0
NaN

Como vimos em uma seção anterior, o infinito é um número de ponto flutuante válido em Julia, representado por Inf.

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