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

julia> 1+2im
1 + 2im

Nous pouvons également effectuer diverses opérations arithmétiques sur les nombres complexes :

Exemples

julia> (1 + 2im)*(2 - 3im)
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

julia> 2(1 - 1im)
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

julia> z = 1 + 2im
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

julia> sqrt(1im)
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

julia> sqrt(-1)
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

julia> a = 1; b = 2; a + b*im
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

julia> a = 1; b = 2; complex(a, b)
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

julia> 1 + Inf*im
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 (, ) sont définis comme des nombres rationnels, par exemple, 0.75 (qui peut être exprimé comme). Les entiers et les fractions sont collectivement appelés nombres rationnels. Par opposition aux nombres rationnels, il y a les nombres irrationnels, tels quequi ne peut pas être exprimé comme un rapport de nombres 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

julia> 2//3
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

julia> 6//9
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

julia> numerator(2//3)
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

julia> 2//3 == 6//9
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

julia> float(3//4)
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> a = 1; b = 2;

julia> isequal(float(a//b), a/b)
vrai

Julia accepte de construire des valeurs de fraction infinies :

Exemples

julia> 5//0
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

julia> 0//0
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

julia> 3//5 + 1
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
Autres extensions