Julia Nombres complexes et rationnels
Dans ce chapitre, nous allons principalement étudier les nombres complexes et rationnels en Julia.
Le langage Julia inclut des types prédéfinis pour les nombres complexes et rationnels, et prend en charge diverses opérations mathématiques standard et fonctions élémentaires sur ceux-ci.
Nombres complexes
Les nombres complexes sont une extension des nombres réels, permettant à toute équation polynomiale d'avoir des racines.
On appelle nombres complexes les nombres de la formez=a+bi(où a et b sont tous deux des nombres réels). Ici, a est appelé partie réelle, b est appelé partie imaginaire, et i est appelé unité imaginaire, qui a la propriété. Lorsque la partie imaginaire b de z est égale à 0, z est un nombre réel ; lorsque la partie imaginaire b de z n'est pas égale à 0 et que la partie réelle a est égale à 0, z est souvent appelé nombre imaginaire pur.
La constante globale im est liée au nombre complexe i, représentant la racine carrée principale de -1.
Comme Julia autorise les littéraux numériques comme coefficients de littéraux numériques, cette liaison suffit à fournir une syntaxe très pratique pour les nombres complexes, semblable à la notation mathématique traditionnelle :
Exemples
1 + 2im
Nous pouvons également effectuer diverses opérations arithmétiques sur les nombres complexes :
Exemples
8 + 1im
julia> (1 + 2im)/(1 - 2im)
-0.6 + 0.8im
julia> (1 + 2im) + (1 - 2im)
2 + 0im
julia> (-3 + 2im) - (5 - 1im)
-8 + 3im
julia> (-1 + 2im)^2
-3 - 4im
julia> (-1 + 2im)^2.5
2.729624464784009 - 6.9606644595719im
julia> (-1 + 2im)^(1 + 1im)
-0.27910381075826657 + 0.08708053414102428im
julia> 3(2 - 5im)
6 - 15im
julia> 3(2 - 5im)^2
-63 - 60im
julia> 3(2 - 5im)^-1.0
0.20689655172413796 + 0.5172413793103449im
Le mécanisme de promotion de type garantit également que vous pouvez utiliser des combinaisons d'opérandes de types différents :
Exemples
2 - 2im
julia> (2 + 3im) - 1
1 + 3im
julia> (1 + 2im) + 0.5
1.5 + 2.0im
julia> (2 + 3im) - 0.5im
2.0 + 2.5im
julia> 0.75(1 + 2im)
0.75 + 1.5im
julia> (2 + 3im) / 2
1.0 + 1.5im
julia> (1 - 3im) / (2 + 2im)
-0.5 - 1.0im
julia> 2im^2
-2 + 0im
julia> 1 + 3/4im
1.0 - 0.75im
Remarque3/4im == 3/(4*im) == -(3/4*im), car le coefficient a une priorité plus élevée que la division.
Julia fournit quelques fonctions standard pour travailler avec les nombres complexes :
Exemples
1 + 2im
julia> real(1 + 2im) # la partie réelle de z
1
julia> imag(1 + 2im) # la partie imaginaire de z
2
julia> conj(1 + 2im) # le conjugué complexe de z
1 - 2im
julia> abs(1 + 2im) # la valeur absolue de z
2.23606797749979
julia> abs2(1 + 2im) # la valeur absolue au carré
5
julia> angle(1 + 2im) # l'angle de phase en radians
1.1071487177940904
Par convention, la valeur absolue (abs) d'un nombre complexe est sa distance à zéro. abs2 donne le carré de la valeur absolue, ce qui est très utile lorsqu'on l'applique à des nombres complexes car cela évite de calculer une racine carrée. angle renvoie l'angle de phase en radians (également appelée fonction argument). Toutes les autres fonctions élémentaires sont également entièrement définies sur les nombres complexes :
Exemples
0.7071067811865476 + 0.7071067811865475im
julia> sqrt(1 + 2im)
1.272019649514069 + 0.7861513777574233im
julia> cos(1 + 2im)
2.0327230070196656 - 3.0518977991517997im
julia> exp(1 + 2im)
-1.1312043837568135 + 2.4717266720048188im
julia> sinh(1 + 2im)
-0.4890562590412937 + 1.4031192506220405im
Notez que les fonctions mathématiques renvoient généralement des valeurs réelles lorsqu'elles sont appliquées à des nombres réels, et renvoient des valeurs complexes lorsqu'elles sont appliquées à des nombres complexes. Par exemple, sqrt se comporte différemment lorsqu'elle est appliquée à -1 et -1 + 0im, même si -1 == -1 + 0im :
Exemples
ERREUR : DomainError avec -1.0:
sqrt ne renverra un résultat complexe que si on l'appelle avec un argument complexe. Essayez sqrt(Complex(x)).
Trace de pile:
[...]
julia> sqrt(-1 + 0im)
0.0 + 1.0im
Lors de la construction de nombres complexes à partir de variables, la notation littérale du coefficient numérique ne s'applique plus. À la place, la multiplication doit être écrite explicitement :
Exemples
1 + 2im
Cependant, ceci n'est pas recommandé. À la place, vous devriez utiliser la fonction complex plus efficace pour construire directement une valeur complexe à partir des parties réelle et imaginaire :
Exemples
1 + 2im
Cette construction évite les opérations de multiplication et d'addition.
Inf et NaN peuvent apparaître dans les parties réelle et imaginaire des nombres complexes, comme décrit dans la section sur les valeurs spéciales à virgule flottante :
Exemples
1.0 + Inf*im
julia> 1 + NaN*im
1.0 + NaN*im
Nombres rationnels
Les nombres rationnels sont le terme collectif pour les nombres entiers (entiers positifs, 0, entiers négatifs) et les fractions, et constituent l'ensemble des nombres entiers et des fractions.
Mathématiquement, les nombres qui peuvent être exprimés comme le rapport de deux entiers (Julia dispose d'un type fraction pour représenter des rapports exacts de nombres entiers. Les fractions sont construites à l'aide de l'opérateur//:
Exemples
2//3
Si le numérateur et le dénominateur d’une fraction ont des facteurs communs, ils sont réduits à la forme la plus simple et le dénominateur est non négatif :
Exemples
2//3
julia> -4//8
-1//2
julia> 5//-15
-1//3
julia> -4//-12
1//3
Cette forme standardisée des rapports d’entiers est unique, donc l’égalité des valeurs de fractions peut être testée en vérifiant que les numérateurs et les dénominateurs sont égaux. Le numérateur et le dénominateur standardisés d’une valeur de fraction peuvent être obtenus à l’aide des fonctions numerator et denominator :
Exemples
2
julia> denominator(2//3)
3
La comparaison directe des numérateurs et des dénominateurs est généralement inutile, car les opérations arithmétiques et de comparaison standard sont également définies pour les valeurs de fraction :
Exemples
vrai
julia> 2//3 == 9//27
false
julia> 3//7 < 1//2
vrai
julia> 3//4 > 2//3
vrai
julia> 2//4 + 1//6
2//3
julia> 5//12 - 1//4
1//6
julia> 5//8 * 3//12
5//32
julia> 6//5 / 10//7
21//25
Les fractions peuvent être facilement converties en nombres à virgule flottante :
Exemples
0.75
Pour toutes les valeurs entières a et b (sauf lorsque a == 0 et b == 0), la conversion des fractions en nombres à virgule flottante suit la cohérence suivante :
Exemples
julia> isequal(float(a//b), a/b)
vrai
Julia accepte de construire des valeurs de fraction infinies :
Exemples
1//0
julia> x = -3//0
-1//0
julia> typeof(x)
Rational{Int64}
Mais il n'accepte pas de tenter de construire une valeur de fraction NaN :
Exemples
ERREUR : ArgumentError : rationnel invalide : zero(Int64)//zero(Int64)
Trace de pile :
[...]
Comme d'habitude, le système de promotion de types facilite l'interaction des fractions avec d'autres types numériques :
Exemples
8//5
julia> 3//5 - 0.5
0.09999999999999998
julia> 2//7 * (1 + 2im)
2//7 + 4//7*im
julia> 2//7 * (1.5 + 2im)
0.42857142857142855 + 0.5714285714285714im
julia> 3//2 / (1 + 2im)
3//10 - 3//5*im
julia> 1//2 + 2im
1//2 + 2//1*im
julia> 1 + 2//3im
1//1 - 2//3*im
julia> 0.5 == 1//2
vrai
julia> 0.33 == 1//3
false
julia> 0.33 < 1//3
vrai
julia> 1//3 - 0.33
0.0033333333333332993