Julia Opérateurs de base

Un opérateur est un symbole qui indique au compilateur d'effectuer des opérations mathématiques ou logiques spécifiques, telles que :3+2=5。

Le langage Julia dispose d'un riche ensemble d'opérateurs intégrés. Les opérations prises en charge sont :

  • Opérateurs arithmétiques
  • Opérateurs logiques
  • Opérateurs relationnels
  • Opérateurs bit à bit
  • Opérateurs d'affectation
  • Opérateurs « point » vectorisés

Opérateurs arithmétiques

Le tableau suivant présente les opérateurs arithmétiques de base de Julia, qui s'appliquent à tous les types numériques de base :

Expression Name Description
+x Opérateur plus unaire Opération d'identité
-x Opérateur moins unaire Transforme la valeur en son négatif
x + y Opérateur d'addition binaire Additionne deux nombres
x - y Opérateur de soustraction binaire Soustrait deux nombres
x * y Opérateur de multiplication Multiplie deux nombres
x / y Opérateur de division Divise deux nombres
x ÷ y Division entière Prend la partie entière de x / y
x \ y Division inverse Équivalent ày / x
x ^ y Opérateur de puissance xdeyPuissance
x % y Reste Équivalent àrem(x,y)

Exemples

julia> 1 + 2 + 3
6
julia> 1 - 2
-1
julia> 3*2/12
0.5
julia> 2+20-5
17
julia> 50*2/10
10.0
julia> 23%2
1
julia> 2^4
16

Opérateurs booléens

Le tableau suivant présente les opérateurs booléens de Julia :

Expression Name
!x Négation
x && y ET court-circuit. Dans l’expression x && y, la sous-expression y n’est exécutée que si x est vrai.
x || y OU court-circuit. Dans l’expression x || y, la sous-expression y n’est exécutée que si x est faux.

Exemples

julia> !true
false

julia> !false
vrai

julia> true && (x = (1, 2, 3))
(1, 2, 3)

julia> false && (x = (1, 2, 3))
false

julia> false || (x = (1, 2, 3))
(1, 2, 3)

Opérateurs relationnels

Le tableau suivant présente les opérateurs relationnels de Julia :

Operator Name
== Égalité
!=, ≠ Inégalité
< Inférieur à
<=, ≤ Inférieur ou égal à
> Supérieur à
>=, ≥ Supérieur ou égal à

Exemples

julia> 100 == 100
vrai

julia> 100 == 101
false

julia> 100 != 101
vrai

julia> 100 == 100.0
vrai

julia> 100 < 500
vrai

julia> 100 > 500
false

julia> 100 >= 100.0
vrai

julia> -100 <= 100
vrai

julia> -100 <= -100
vrai

julia> -100 <= -500
false

julia> 100 < -10.0
false

Comparaisons chaînées

Les comparaisons chaînées sont particulièrement pratiques lors de l'écriture de code numérique. Elles utilisent l'opérateur && pour comparer des scalaires, et pour les tableaux, elles utilisent & pour effectuer une comparaison élément par élément. Par exemple, 0 .< A .< 1 produit un tableau booléen dont tous les éléments sont true si les éléments de A sont tous compris entre 0 et 1.

Julia permet les comparaisons chaînées :

Exemples

julia> 1 < 2 <= 2 < 3 == 3 > 2 >= 1 == 1 < 3 != 5
vrai

Notez l'ordre d'évaluation des comparaisons chaînées :

Exemples

julia> M(a) = (println(a); a)
M (fonction générique avec 1 méthode)
julia> M(1) < M(2) <= M(3)
 2
 1
 3
vrai
julia> M(1) > M(2) <= M(3)
 2
 1
false

Opérateurs bit à bit

Le tableau suivant présente les opérateurs bit à bit de Julia :

Expression Name
~x NON bit à bit
x & y ET bit à bit
x | y OU bit à bit
x ⊻ y XOR bit à bit (OU exclusif logique)
x ⊼ y NAND bit à bit
x ⊽ y NOR bit à bit
x >>> y Décalage à droite logique
x >> y Décalage à droite arithmétique
x << y Décalage à gauche logique/arithmétique

Exemples

julia> ~123
-124

julia> 123 & 234
106

julia> 123 | 234
251

julia> 123 ⊻ 234
145

julia> xor(123, 234)
145

julia> nand(123, 123)
-124

julia> 123 ⊼ 123
-124

julia> nor(123, 124)
-128

julia> 123 ⊽ 124
-128

julia> ~UInt32(123)
0xffffff84

julia> ~UInt8(123)
0x84

Opérateurs d'affectation

Chaque opérateur binaire et opérateur bit à bit peut effectuer une affectation composée à l'opérande gauche en plaçant = directement après l'opérateur binaire. Par exemple,x += 3est équivalent à x = x + 3 。

Le tableau suivant présente les opérateurs d'affectation de Julia :

OperatorDescriptionExemple
=Opérateur d'affectation simple : affecte la valeur de l'opérande droit à l'opérande gauche.C = A + B affecte la valeur de A + B à C
+=Opérateur d'addition et d'affectation : affecte à l'opérande gauche le résultat de l'addition de l'opérande droit à l'opérande gauche.C += A équivaut à C = C + A
-=Opérateur de soustraction et d'affectation : affecte à l'opérande gauche le résultat de la soustraction de l'opérande droit de l'opérande gauche.C -= A est équivalent à C = C - A
*=Opérateur de multiplication et d'affectation : affecte à l'opérande gauche le résultat de la multiplication de l'opérande droit par l'opérande gauche.C *= A est équivalent à C = C * A
/=Opérateur de division et d'affectation : affecte à l'opérande gauche le résultat de la division de l'opérande gauche par l'opérande droit.C /= A est équivalent à C = C / A
%=Opérateur de modulo et d'affectation : affecte le modulo des deux opérandes à l'opérande gauche.C %= A est équivalent à C = C % A
<<=Opérateur de décalage à gauche et d'affectationC <<= 2 est équivalent à C = C << 2
>>=Opérateur de décalage à droite et d'affectationC >>= 2 est équivalent à C = C >> 2
&=Opérateur ET bit à bit et d'affectationC &= 2 est équivalent à C = C & 2
^=Opérateur XOR bit à bit et d'affectationC ^= 2 est équivalent à C = C ^ 2
|=Opérateur OR bit à bit et d'affectationC |= 2 est équivalent à C = C | 2
>>>=Opérateur de décalage à droite logique et d'affectationC >>>= 2 est équivalent à C = C >>>2
⊻=Opérateur d'affectation XOR (OU exclusif logique)C ⊻= 2 est équivalent à C = C ⊻= 2

Exemples

julia> x = 1
1

julia> x += 3
4

julia> x
4

Opérateurs « point » vectorisés

En Julia, chaque opérateur binaire a un opérateur "point" correspondant ; par exemple,^il existe un.^correspondant. Ce.^correspondant est automatiquement défini par Julia pour effectuer des opérations élément par élément^opération. Par exemple,[1,2,3] ^ 3est illégal, car les mathématiques n'ont pas défini le cube d'un tableau (avec des longueurs de ligne et de colonne différentes). Mais[1,2,3] .^ 3est légal en Julia, et il effectue l'opération ^ élément par élément (aussi appelée opération vectorisée), donnant [1^3, 2^3, 3^3]. De même,!ou√les opérateurs unaires comme celui-ci ont aussi un.√ correspondant utilisé pour effectuer des opérations élément par élément.

Exemples

julia> [1,2,3] .^ 3
3-element Vector{Int64}:
  1
  8
 27

En plus des opérateurs point, nous avons aussi des opérateurs d'affectation élément par élément, tels quea .+= b(ou@. a += b) est analysé commea .= a .+ b。

Précédence et associativité des opérateurs

La priorité des opérateurs détermine le regroupement des termes dans une expression. Cela affecte la façon dont une expression est évaluée. Certains opérateurs ont une priorité plus élevée que d'autres ; par exemple, les opérateurs de multiplication et de division ont une priorité plus élevée que les opérateurs d'addition et de soustraction.

Par exemplex = 7 + 3 * 2, ici, x reçoit 13 au lieu de 20, car l'opérateur*a+une précédence plus élevée, donc la multiplication 3*2 est calculée en premier, puis ajoutée à 7.

Le tableau suivant répertorie les opérateurs par priorité, de la plus élevée à la plus faible. Les opérateurs ayant une priorité plus élevée apparaissent en haut du tableau, et les opérateurs ayant une priorité plus faible apparaissent en bas. Dans une expression, les opérateurs ayant une priorité plus élevée sont évalués en premier.

Catégorie Operator Associativité
Syntaxe . suivi de :: Associatif à gauche
Exponentiation ^ Associatif à droite
Opérateurs unaires + - √ Associatif à droite
Opérations de décalage << >> >>> Associatif à gauche
Division // Associatif à gauche
Multiplication * / % & \ ÷ Associatif à gauche
Addition + - | ⊻ Associatif à gauche
Syntaxe : .. Associatif à gauche
Syntaxe |> Associatif à gauche
Syntaxe <| Associatif à droite
Comparaison > < >= <= == === != !== <: Non associatif
Contrôle du flux && suivi de || suivi de ? Associatif à droite
Opérations sur les paires => Associatif à droite
Affectation = += -= *= /= //= \= ^= ÷= %= |= &= ⊻= <<= >>= >>>= Associatif à droite

Nous pouvons également utiliser la fonction intégréeBase.operator_precedencepour afficher la valeur de priorité de n'importe quel opérateur donné ; plus la valeur est grande, plus la priorité est élevée.

Exemples

julia> Base.operator_precedence(:+), Base.operator_precedence(:*), Base.operator_precedence(:.)
(11, 12, 17)

julia> Base.operator_precedence(:sin), Base.operator_precedence(:+=), Base.operator_precedence(:(=))  # (Remarque : il doit y avoir des parenthèses autour du signe égal `:(=)`)
(0, 1, 1)

De plus, les fonctions intégréesBase.operator_associativitypeuvent renvoyer une représentation symbolique de l'associativité des opérateurs :

Exemples

julia> Base.operator_associativity(:-), Base.operator_associativity(:+), Base.operator_associativity(:^)
(:left, :none, :right)

julia> Base.operator_associativity(:⊗), Base.operator_associativity(:sin), Base.operator_associativity(:→)
(:left, :none, :right)
Autres extensions