Julia Language
Arithmétique

Syntaxe

• + x
• -X
• a + b
• un B
• un B
• un B
• a ^ b
• un B
• 4a
• sqrt (a)

Formule quadratique

Julia utilise des opérateurs binaires similaires pour les opérations arithmétiques de base, comme le font les mathématiques ou d'autres langages de programmation. La plupart des opérateurs peuvent être écrits en notation infixe (c'est-à-dire placés entre les valeurs en cours de calcul). Julia a un ordre des opérations qui correspond à la convention commune en mathématiques.

Par exemple, le code ci-dessous implémente la formule quadratique , qui montre les opérateurs + , - , * et / pour l'addition, la soustraction, la multiplication et la division, respectivement. La multiplication implicite est également indiquée, dans laquelle un nombre peut être placé directement avant un symbole pour signifier la multiplication; c'est-à-dire que 4a signifie la même chose que 4*a .

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

Usage:

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

Tamis d'Ératosthène

L'opérateur restant dans Julia est l'opérateur % . Cet opérateur se comporte comme le % dans les langages tels que C et C ++. a % b est le reste signé après avoir divisé a par b .

Cet opérateur est très utile pour implémenter certains algorithmes, tels que l'implémentation suivante du Sieve of Eratosthenes .

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

Usage:

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

Arithmétique Matricielle

Julia utilise la signification mathématique standard des opérations arithmétiques lorsqu'elle est appliquée à des matrices. Parfois, des opérations élémentaires sont souhaitées à la place. Celles-ci sont marquées d'un arrêt complet ( . ) Précédant l'opérateur à effectuer élément par élément. (Notez que les opérations élémentaires ne sont souvent pas aussi efficaces que les boucles.)

Les sommes

L'opérateur + sur les matrices est une somme matricielle. Il est similaire à une somme élémentaire, mais ne diffuse pas de forme. C'est-à-dire que si A et B ont la même forme, alors A + B est identique à A .+ B ; sinon, A + B est une erreur, alors que A .+ B peut ne pas l'être nécessairement.

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

De même, - calcule une différence de matrice. Les deux + et - peuvent également être utilisés comme opérateurs unaires.

Des produits

L'opérateur * sur les matrices est le produit de la matrice (pas le produit élément par élément). Pour un produit élément par élément, utilisez l'opérateur. .* . Comparez (en utilisant les mêmes matrices que ci-dessus):

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

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

Pouvoirs

L'opérateur ^ calcule l' exponentiation de la matrice . Une exponentiation matricielle peut être utile pour calculer rapidement les valeurs de certaines récurrences. Par exemple, les nombres de Fibonacci peuvent être générés par l' expression de la matrice

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

Comme d'habitude, l'opérateur .^ Peut être utilisé lorsque l'exponentiation élément par élément est l'opération souhaitée.