Types de données Julia

Dans les langages de programmation, il y a des opérations mathématiques de base et des calculs scientifiques. Leurs types de données couramment utilisés sontles entiersetles nombresà virgule flottante.

De plus, il existe également un terme"littéral". Un littéral est une notation utilisée pour exprimer une valeur fixe dans le code source. Les entiers, les nombres à virgule flottante, les chaînes de caractères, etc. sont tous des littéraux.

Par exemple :

a=1 // a est une variable, 1 est un littéral entier b=1.0 // b est une variable, 1.0 est un littéral à virgule flottante

Julia fournit un riche ensemble de types numériques primitifs et définit un ensemble complet d'opérations arithmétiques basées sur ceux-ci. De plus, il fournit également des opérateurs bit à bit et quelques fonctions mathématiques standard.


Types entiers

Le tableau suivant répertorie les types entiers pris en charge par Julia :

Type Signé ? Nombre de bits Valeur minimale Valeur maximale
Int8 ✓ 8 -2^7 2^7 – 1
UInt8 8 0 2^8 – 1
Int16 ✓ 16 -2^15 2^15 – 1
UInt16 16 0 2^16 – 1
Int32 ✓ 32 -2^31 2^31 – 1
UInt32 32 0 2^32 – 1
Int64 ✓ 64 -2^63 2^63 – 1
UInt64 64 0 2^64 – 1
Int128 ✓ 128 -2^127 2^127 – 1
UInt128 128 0 2^128 – 1
Bool N/A 8 false (0) true (1)

Formes de littéraux entiers :

Exemple

julia> 1
1

julia> 1234
1234

Le type par défaut d’un littéral entier dépend du fait que le système cible est une architecture 32 bits ou 64 bits (la plupart des systèmes actuels sont 64 bits) :

Exemple

# Système 32 bits :
julia> typeof(1)
Int32

# Système 64 bits :
julia> typeof(1)
Int64

La variable intégrée de JuliaSys.WORD_SIZEindique si le système cible est une architecture 32 bits ou 64 bits :

Exemple

# Système 32 bits :
julia> Sys.WORD_SIZE
32

# Système 64 bits :
julia> Sys.WORD_SIZE
64

Julia définit également les types Int et UInt, qui sont respectivement des alias pour les types entiers natifs signés et non signés du système.

Exemple

# Système 32 bits :
julia> Int
Int32
julia> UInt
UInt32

# Système 64 bits :
julia> Int
Int64
julia> UInt
UInt64

Comportement de débordement

En Julia, dépasser la valeur maximale représentable par un type provoque un comportement de rebouclage :

Exemple

julia> x = typemax(Int64)
9223372036854775807

julia> x + 1
-9223372036854775808

julia> x + 1 == typemin(Int64)
vrai

Par conséquent, l'arithmétique entière de Julia est en fait une forme d'arithmétique modulaire, reflétant les caractéristiques de la façon dont les ordinateurs modernes implémentent l'arithmétique de bas niveau. Dans les programmes où un débordement peut se produire, des vérifications explicites du rebouclage aux limites des valeurs extrêmes sont nécessaires. Sinon, le type BigInt de l'arithmétique à précision arbitraire est recommandé comme alternative.

Voici un exemple de comportement de débordement et de la façon de résoudre un débordement :

Exemple

julia> 10^19
-8446744073709551616

julia> big(10)^19
10000000000000000000

Erreurs de division

La division entière déclenche une DivideError dans les deux cas exceptionnels suivants :
  • Division par zéro
  • Division par le plus petit nombre négatif

remLa fonction de reste etmodla fonction modulo lèvent une DivideError lors d'une division par zéro. Voici un exemple :

Exemple

julia> mod(1, 0)
ERROR: DivideError: erreur de division entière
Trace de pile :
 [1] div à .\int.jl:260 [inlined]
 [2] div à .\div.jl:217 [inlined]
 [3] div à .\div.jl:262 [inlined]
 [4] fld à .\div.jl:228 [inlined]
 [5] mod(::Int64, ::Int64) à .\int.jl:252
 [6] portée de niveau supérieur dans le REPL[52]:1
 
 
julia> rem(1, 0)
ERROR: DivideError: erreur de division entière
Trace de pile :
 [1] rem(::Int64, ::Int64) à .\int.jl:261
 [2] portée de niveau supérieur dans le REPL[54]:1

Types à virgule flottante

Le tableau suivant répertorie les types à virgule flottante pris en charge par Julia :

Type Precision Nombre de bits
Float16 Demi-précision 16
Float32 Précision simple 32
Float64 Double précision 64

De plus, la prise en charge complète des nombres complexes et rationnels est construite au-dessus de ces types de données primitifs.

Le format des littéraux à virgule flottante est présenté ci-dessous. Si nécessaire, vous pouvez utiliserEpour l'exprimer.

Exemple

julia> 1.0
1.0

julia> 1.
1.0

julia> 0.5
0.5

julia> .5
0.5

julia> -1.23
-1.23

julia> 1e10
1.0e10

julia> 2.5e-4
0.00025

Remarque :

En notation scientifique, pour simplifier les formules, le format avecEpeut être utilisé pour la représentation. Par exemple, 1.03 fois 10 à la puissance 8 peut être abrégé en "1.03E+08", où "E" est l'abréviation d'exposant.

Les résultats ci-dessus sont tous des valeurs Float64. L'utilisation de f au lieu de e donne des littéraux Float32 :

Exemple

julia> x = 0.5f0
0.5f0

julia> typeof(x)
Float32

julia> 2.5f-4
0.00025f0
Les nombres peuvent être facilement convertis en typeFloat32:

julia> x = Float32(-1.5)
-1.5f0

julia> typeof(x)
Float32

Il existe également des littéraux hexadécimaux à virgule flottante, mais ils ne s'appliquent qu'aux valeurs de type Float64. Ils sont généralement représentés à l'aide du préfixe p et d'un exposant de base 2 :

Exemple

julia> 0x1p0
1.0

julia> 0x1.8p3
12.0

julia> x = 0x.4p-1
0.125

julia> typeof(x)
Float64
Julia prend également en charge les nombres à virgule flottante en demi-précision (Float16), mais ils sontFloat32implémentés par émulation logicielle.

julia> sizeof(Float16(4.))
2

julia> 2*Float16(4.)
Float16(8.0)

Le trait de soulignement_peut être utilisé comme séparateur de chiffres :

Exemple

julia> 10_000, 0.000_000_005, 0xdead_beef, 0b1011_0010
(10000, 5.0e-9, 0xdeadbeef, 0xb2)

Zéro dans les nombres à virgule flottante

Les nombres à virgule flottante ont deux types de zéros : le zéro positif et le zéro négatif. Ils sont égaux entre eux mais ont des représentations binaires différentes, que l'on peut visualiser à l'aide de la fonction bitstring :

Exemple

julia> 0.0 == -0.0
vrai

julia> bitstring(0.0)
"0000000000000000000000000000000000000000000000000000000000000000"

julia> bitstring(-0.0)
"1000000000000000000000000000000000000000000000000000000000000000"

Valeurs spéciales en virgule flottante

Il existe trois valeurs standard spécifiques en virgule flottante qui ne correspondent à aucun point de la droite des nombres réels :

Float16 Float32 Float64 Name Description
Inf16 Inf32 Inf Infini positif Un nombre supérieur à tous les nombres à virgule flottante finis
-Inf16 -Inf32 -Inf Infini négatif Un nombre inférieur à tous les nombres à virgule flottante finis
NaN16 NaN32 NaN Pas un nombre Une valeur qui n'est égale (==) à aucune valeur à virgule flottante (y compris elle-même)

Ce qui suit présente quelques exemples d'opérations sur les nombres à virgule flottante :

Exemple

julia> 1/Inf
0.0

julia> 1/0
Inf

julia> -5/0
-Inf

julia> 0.000001/0
Inf

julia> 0/0
NaN

julia> 500 + Inf
Inf

julia> 500 - Inf
-Inf

julia> Inf + Inf
Inf

julia> Inf - Inf
NaN

julia> Inf * Inf
Inf

julia> Inf / Inf
NaN

julia> 0 * Inf
NaN

julia> NaN == NaN
false

julia> NaN != NaN
vrai

julia> NaN < NaN
false

julia> NaN > NaN
false

Nous pouvons également utiliser les fonctions typemin et typemax :

Exemple

julia> (typemin(Float16),typemax(Float16))
(-Inf16, Inf16)

julia> (typemin(Float32),typemax(Float32))
(-Inf32, Inf32)

julia> (typemin(Float64),typemax(Float64))
(-Inf, Inf)

Précision machine

La plupart des nombres réels ne peuvent pas être représentés exactement par des nombres à virgule flottante, il est donc nécessaire de connaître la distance entre deux nombres à virgule flottante représentables adjacents, ce que l'on appelle généralement la précision machine.

Julia fournit la fonctioneps, qui donne la différence entre 1.0 et le prochain nombre à virgule flottante que Julia peut représenter :

Exemple

julia> eps(Float32)
1.1920929f-7

julia> eps(Float64)
2.220446049250313e-16

julia> eps() # Identique à eps(Float64)
2.220446049250313e-16

Ces valeurs sont respectivement 2.0^-23 en Float32 et 2.0^-52 en Float64. La fonction eps peut également prendre une valeur à virgule flottante comme argument et renvoyer la différence absolue entre cette valeur et la valeur à virgule flottante représentable suivante. Autrement dit, eps(x) renvoie une valeur du même type que x, et x + eps(x) est exactement la valeur à virgule flottante représentable suivante supérieure à x :

Exemple

julia> eps(1.0)
2.220446049250313e-16

julia> eps(1000.)
1.1368683772161603e-13

julia> eps(1e-27)
1.793662034335766e-43

julia> eps(0.0)
5.0e-324

La distance entre deux nombres à virgule flottante représentables adjacents n'est pas constante : plus le nombre est petit, plus l'écart est petit ; plus le nombre est grand, plus l'écart est grand. En d'autres termes, les nombres à virgule flottante représentables sont les plus denses près de zéro sur la droite des nombres réels, et deviennent de plus en plus clairsemés de façon exponentielle à mesure qu'ils s'éloignent de zéro. Par définition, eps(1.0) est égal à eps(Float64), car 1.0 est une valeur à virgule flottante de 64 bits.

Julia fournit également deux fonctions, nextfloat et prevfloat, qui renvoient respectivement le prochain nombre à virgule flottante représentable plus grand ou plus petit en fonction de l'argument :

Exemple

julia> x = 1.25f0
1.25f0

julia> nextfloat(x)
1.2500001f0

julia> prevfloat(x)
1.2499999f0

julia> bitstring(prevfloat(x))
"00111111100111111111111111111111"

julia> bitstring(x)
"00111111101000000000000000000000"

julia> bitstring(nextfloat(x))
"00111111101000000000000000000001"

Cet exemple illustre le principe général selon lequel des nombres à virgule flottante représentables adjacents ont également des représentations binaires entières adjacentes.


Modes d'arrondi

Si un nombre n'a pas de représentation exacte en virgule flottante, il doit être arrondi à une valeur représentable appropriée.

Le mode par défaut utilisé par Julia est toujoursRoundNearest, ce qui signifie arrondir à la valeur représentable la plus proche, et la valeur arrondie utilise le moins de chiffres significatifs possible.

Exemple

julia> BigFloat("1.510564889",2,RoundNearest)
1.5

julia> BigFloat("1.550564889",2,RoundNearest)
1.5

julia> BigFloat("1.560564889",2,RoundNearest)
1.5

Littéraux zéro et un

Julia fournit des fonctions littérales pour 0 et 1, qui peuvent renvoyer le littéral d'un type spécifique ou le type d'une variable donnée.

FonctionDescription
zero(x)Littéral zéro de type x ou du type de la variable x
one(x)Littéral un de type x ou du type de la variable x

Ces fonctions peuvent être utilisées dans des comparaisons numériques pour éviter la surcharge liée aux conversions de type inutiles.

Par exemple :

Exemple

julia> zero(Float32)
0.0f0

julia> zero(1.0)
0.0

julia> one(Int32)
1

julia⟦⟧> one(BigFloat)
1.0

Conversion de type

La conversion de type est le processus de conversion d'une variable d'un type vers un autre type de données. Par exemple, si vous voulez stocker une valeur flottante dans un entier simple, vous devez convertir la valeur flottante en un type int. Vous pouvez utiliser l'opérateur de cast pour convertir explicitement une valeur d'un type en un autre, comme indiqué ci-dessous :

Julia prend en charge trois types de conversion numérique, qui diffèrent dans leur façon de gérer les conversions inexactes.

Le premier type :

T(x) 
或
convert(T,x) 

Toutes les formes ci-dessus convertissent x en type T.

  • Si T est un type à virgule flottante, le résultat est la valeur représentable la plus proche, qui peut être l'infini positif ou négatif.
  • Si T est un type entier, une InexactError est levée lorsque x ne peut pas être représenté par le type T.

Le deuxième type :

x % TIl est également possible de convertir un entier x en un type entier T, conformément au résultat de x modulo 2^n, où n est le nombre de bits de T.

Le troisième type :

Les fonctions d'arrondi prennent un argument facultatif de type T. Par exemple, round(Int,x) est la forme abrégée deInt(round(x)).

Exemple

julia> Int8(127)
127

julia> Int8(128)
ERROR: InexactError: trunc(Int8, 128)
Trace de pile :
[...]

julia> Int8(127.0)
127

julia> Int8(3.14)
ERROR: InexactError: Int8(3.14)
Trace de pile :
[...]

julia> Int8(128.0)
ERROR: InexactError: Int8(128.0)
Trace de pile :
[...]

julia> 127 % Int8
127

julia> 128 % Int8
-128

julia> round(Int8,127.4)
127

julia> round(Int8,127.6)
ERROR: InexactError: trunc(Int8, 128.0)
Trace de pile :
[...]
Autres extensions