Julia Language
Aritmetica

Sintassi

• + x
• -X
• a + b
• a - b
• a * b
• a / b
• a ^ b
• a% b
• 4a
• sqrt (a)

Formula quadratica

Julia usa operatori binari simili per operazioni aritmetiche di base come la matematica o altri linguaggi di programmazione. La maggior parte degli operatori può essere scritta in notazione infix (ovvero, posizionata tra i valori calcolati). Julia ha un ordine di operazioni che corrisponde alla convenzione comune in matematica.

Ad esempio, il codice seguente implementa la formula quadratica , che dimostra rispettivamente gli operatori + , - , * e / per addizione, sottrazione, moltiplicazione e divisione. Viene anche mostrata la moltiplicazione implicita , in cui un numero può essere posizionato direttamente prima di un simbolo per indicare la moltiplicazione; cioè, 4a significa lo stesso di 4*a .

function solvequadratic(a, b, c)
    d = sqrt(b^2 - 4a*c)
    (-b - d) / 2a, (-b + d) / 2a
end

Uso:

julia> solvequadratic(1, -2, -3)
(-1.0,3.0)

Setaccio di Eratostene

L'operatore rimanente in Julia è l'operatore % . Questo operatore si comporta in modo simile alla % in lingue come C e C ++. a % b è il resto firmato rimasto dopo aver diviso a da b .

Questo operatore è molto utile per l'implementazione di determinati algoritmi, come la seguente implementazione del setaccio di Eratostene .

iscoprime(P, i) = !any(x -> i % x == 0, P)

function sieve(n)
    P = Int[]
    for i in 2:n
        if iscoprime(P, i)
            push!(P, i)
        end
    end
    P
end

Uso:

julia> sieve(20)
8-element Array{Int64,1}:
  2
  3
  5
  7
 11
 13
 17
 19

Matrix Arithmetic

Julia usa i significati matematici standard delle operazioni aritmetiche quando applicato alle matrici. A volte, invece, si preferiscono operazioni elementwise. Questi sono contrassegnati da un punto ( . ) Che precede l'operatore da eseguire elementwise. (Nota che le operazioni elementwise spesso non sono efficienti come i loop).

Le somme

L'operatore + sulle matrici è una somma matrice. È simile a una somma elementwise, ma non trasmette la forma. Cioè, se A e B hanno la stessa forma, allora A + B è lo stesso di A .+ B ; altrimenti, A + B è un errore, mentre A .+ B potrebbe non essere necessariamente.

julia> A = [1 2
            3 4]
2×2 Array{Int64,2}:
 1  2
 3  4

julia> B = [5 6
            7 8]
2×2 Array{Int64,2}:
 5  6
 7  8

julia> A + B
2×2 Array{Int64,2}:
  6   8
 10  12

julia> A .+ B
2×2 Array{Int64,2}:
  6   8
 10  12

julia> C = [9, 10]
2-element Array{Int64,1}:
  9
 10

julia> A + C
ERROR: DimensionMismatch("dimensions must match")
 in promote_shape(::Tuple{Base.OneTo{Int64},Base.OneTo{Int64}}, ::Tuple{Base.OneTo{Int64}}) at ./operators.jl:396
 in promote_shape(::Array{Int64,2}, ::Array{Int64,1}) at ./operators.jl:382
 in _elementwise(::Base.#+, ::Array{Int64,2}, ::Array{Int64,1}, ::Type{Int64}) at ./arraymath.jl:61
 in +(::Array{Int64,2}, ::Array{Int64,1}) at ./arraymath.jl:53

julia> A .+ C
2×2 Array{Int64,2}:
 10  11
 13  14

Analogamente, - calcola una differenza matrice. Sia + che - possono anche essere usati come operatori unari.

Prodotti

L'operatore * sulle matrici è il prodotto matrice (non il prodotto elementwise). Per un prodotto elementwise, utilizzare l'operatore. .* . Confronta (usando le stesse matrici come sopra):

julia> A * B
2×2 Array{Int64,2}:
 19  22
 43  50

julia> A .* B
2×2 Array{Int64,2}:
  5  12
 21  32

potenze

L'operatore ^ calcola l' esponenziazione della matrice . L'esponenziazione della matrice può essere utile per calcolare rapidamente i valori di determinate ricorrenze. Ad esempio, i numeri di Fibonacci possono essere generati dall'espressione della matrice

fib(n) = (BigInt[1 1; 1 0]^n)[2]

Come al solito, l'operatore .^ Può essere utilizzato laddove l'esponenziazione elementwise è l'operazione desiderata.