Operações Básicas

Julia conta com um série de operações matemáticas básicas como potênciação, multiplicação, soma, subtração e divisão.

(2^2)*(5 + 3 - 1)/14

2.0

A operação de divisão sempre retorna um valor do tipo Float64. Também temos a divisão inteira (÷) e resto de divisão (%):

(10 ÷ 3) % 2 

1

Outras operações básicas:

Expressão	Descrição
x + y	adição
x - y	subtração
x * y	multiplicação
x / y	divisão
x ÷ y	divisão inteira
x \ y	divisão inversa
x ^ y	potenciação
x % y	resto da divisão

Nota

Cada operador aritmético binário possui uma versão de atualização que atribui o resultado da operação de volta ao operando da esquerda. A versão de atualização do operador binário é formada colocando um sinal de igual imediatamente após o operador. Por exemplo, escrever x += 1 é equivalente a escrever x = x + 1:

x = 9
x += 1 # x = x + 1
println("x = ", x)

x *= 2 # x = x * 2
println("x = ", x)

x = 10
x = 20

Para arredondamento usamos a função round:

println("Arredondar pi: ", round(pi))
println("Arredondar pi com duas casas: ", round(pi; digits=2))
println("Arredondar pi dois digitos significativos: ", round(pi; sigdigits=2))

Arredondar pi: 3.0
Arredondar pi com duas casas: 3.14
Arredondar pi dois digitos significativos: 3.1

Comparações numéricas

Para verificar se duas variáveis guardam o mesmo valor, usamos operador de comparação ==:

eixo_x = 10
eixo_y = 5 
println("eixo_x == eixo_y: ", eixo_x == eixo_y)
println("eixo_x == eixo_y: ", eixo_x == eixo_y+5)

eixo_x == eixo_y: false
eixo_x == eixo_y: true

Outras comparações básicas:

Expressão	Descrição
!=, ≠	desigualdade
<	menor que
<=, ≤	menor que ou igula a
>	maior que
>=, ≥	maior que ou igual a

As comparações podem ser arbitrariamente encadeadas:

-4 < 0 ≤ 20

true

Operações booleanas

Os tipos booleanos suportam três operações: negação, conjunção e disjunção.

A negação modifica true para false e vice-versa.

println("!true: ", !true) 
println("!false: ", !false) 

!true: false
!false: true

A conjunção é uma operação que retorna true se ambos os argumentos são true.

println("true && true: ", true && true) 
println("true && false: ", true && false) 
println("false && true: ", false && true) 
println("false && false: ", false && false)  

true && true: true
true && false: false
false && true: false
false && false: false

Por fim, a disjunção é uma operação que retorna false se ambos os argumentos são false.

println("true || true: ", true || true) 
println("true || false: ", true || false) 
println("false || true: ", false || true) 
println("false || false: ", false || false)  

true || true: true
true || false: true
false || true: true
false || false: false

Podemos resumir com a sequite tabela:

Expressão	Descrição
!x	negação (not)
x && y	conjunção (and)
x || y	disjunção (or)

Importante

As operações funcionam em modo short-circuiting (curto-circuito). Isso significa que elas não necessariamente avaliam o segundo argumento.

val = true
val || println("Acesso Negado")
val && println("Acesso Liberado")

Acesso Liberado

No exemplo acima, como val é true, na operação or não é necessário avaliar o segundo argumento, pois o valor da expressão não depende mais deste argumento. Já na segundo operação and, é preciso avaliar o segundo argumento.

Na expressão x && y, a subexpressão y somente é avaliada se x for true. Já na expressão x || y, a subexpressão y somente é avaliada se x for false. Este comportamento é frequentemente usado como alternativa a pequenos controles de fluxo que usam if.