Introduction
Rational numbers sont des fractions avec un numérateur entier divisé par un dénominateur entier.
Par exemple, on peut stocker 2//3 comme une fraction exacte au lieu de la valeur approximative Float64 0.6666...
L'avantage est que (sauf dans le cas extrême du débordement d'entier) un nombre rationnel restera exact, ce qui évite les erreurs d'arrondi souvent inévitables avec les nombres à virgule flottante.
Les nombres rationnels sont un type numérique assez simple et se comportent globalement comme on peut s'y attendre.
Comme ils font partie des types standard de Julia depuis les premières versions, la plupart des fonctions les acceptent en entrée de la même manière que les entiers et les nombres à virgule flottante.
Crée des nombres rationnels
La création est aussi simple que d'utiliser // entre deux entiers.
julia> 3//4
3//4
julia> a = 3; b = 4;
julia> a//b
3//4
Les facteurs communs sont automatiquement supprimés, ce qui réduit la fraction à sa « forme irréductible » : les plus petits entiers qui représentent exactement la fraction, avec un dénominateur positif ou nul.
julia> 5//15
1//3
julia> 5//-15
-1//3
Arithmétique avec les nombres rationnels
Les arithmetic operators habituels + - * / ^ % fonctionnent avec les rationnels, essentiellement de la même manière qu'avec les autres types numériques.
On peut inclure des entiers et d'autres Rational et obtenir un résultat de type Rational.
Inclure un float dans l'expression produit une sortie de type float, avec une perte de précision (possible) en conséquence.
Si l'on souhaite un float, il suffit d'utiliser la fonction float() pour convertir un rationnel.
Il est tout à fait normal d'utiliser des nombres rationnels pour préserver la précision pendant un long calcul, puis de convertir en nombre à virgule flottante à la fin.
julia> 3//4 + 1//3 # addition
13//12
julia> 3//4 * 1//3 # multiplication
1//4
julia> 3//4 / 1//3 # division
9//4
julia> 3//4 ^ 2 # exponentiation
3//16
julia> 3//4 + 5 # rational and int => rational
23//4
julia> 3//4 + 5.3 # rational and float => float
6.05
julia> float(3//4) # casting
0.75
Autres opérations
En Julia, les nombres rationnels sont des nombres comme les autres.
Le compilateur convertit en général les types si nécessaire.
Cependant, attention : les comparaisons ne fonctionnent que pour les fractions ayant une représentation décimale finie :
julia> 3//4 == 0.75
true
julia> 3//4 < 0.74
false
Mais, sinon, il faut convertir un Rational en Float pour les comparaisons :
julia> 1//3 == 1/3
false
julia> float(1//3) == 1/3
true
Les fonctions mathématiques prennent des rationnels en entrée, mais peuvent donner un résultat à virgule flottante :
julia> sqrt(9//16)
0.75
Instructions
Une organisation de recherche a remarqué que certains de ses jeunes chercheurs utilisaient des méthodes peu optimales dans leurs analyses.
L'une de ces méthodes consiste à convertir immédiatement des probabilités discrètes en nombres décimaux (c'est-à-dire des nombres réels) avant de poursuivre les calculs.
Les chercheurs plus expérimentés préfèrent utiliser des nombres rationnels dans les calculs, ce qui peut offrir une meilleure précision, et ils aimeraient savoir si les mauvaises pratiques des jeunes chercheurs ont affecté les résultats des études.
Deux types d'études ont été menées :
- De nombreux tests ont été lancés, chacun renvoyant une probabilité discrète de succès, puis la moyenne de ces probabilités a été calculée.
- De nombreux événements indépendants ont été testés, et la probabilité totale que tous ces événements se produisent a été calculée en les multipliant entre eux.
Les chercheurs expérimentés te demandent d'écrire des fonctions qui peuvent les aider à déterminer si les analyses faites avec des nombres décimaux comportent des erreurs d'arrondi, et de leur fournir un nombre rationnel précis pour le résultat s'il y a des erreurs.
1. Donne le rapport entre les succès et les essais
La fonction rationalize(successes, trials) prend deux tableaux, successes et trials.
Pour un indice i, successes[i] correspond au nombre de succès obtenus sur trials[i] essais.
La fonction renvoie un tableau de nombres rationnels représentant le rapport des succès sur le nombre d'essais, dans le même ordre que les tableaux d'entrée.
julia> rationalize([1, 2, 3], [4, 5, 6])
3-element Vector{Rational{Int64}}:
1//4
2//5
1//2
2. Trouve les probabilités réelles associées aux succès et aux essais
De même, la fonction probabilities(successes, trials) prend deux tableaux, successes et trials.
Elle renvoie un tableau de nombres décimaux représentant le rapport des succès sur le nombre d'essais, dans le même ordre que les tableaux d'entrée.
julia> probabilities([1, 2, 3], [4, 5, 6])
3-element Vector{Float64}:
0.25
0.4
0.5
3. Vérifie la moyenne des probabilités
La fonction checkmean(successes, trials) prend les deux tableaux, successes et trials.
Elle compare la moyenne des probabilités réelles à la moyenne des probabilités rationnelles.
- Si les deux probabilités sont égales,
checkmean renvoie true
- Si les deux probabilités sont différentes,
checkmean renvoie la probabilité rationnelle.
julia> successes, trials = [9, 4, 7, 8, 6], [22, 22, 11, 17, 12];
julia> checkmean(successes, trials)
true
julia> successes, trials = [6, 5, 9, 8, 9], [21, 19, 13, 25, 22];
julia> checkmean(successes, trials)
1873629//4754750
4. Vérifie la probabilité des événements indépendants
La fonction checkprob(successes, trials) prend les deux tableaux, successes et trials.
Elle compare la probabilité totale obtenue avec les probabilités décimales à la probabilité totale obtenue avec les probabilités rationnelles.
- Si les deux probabilités sont égales,
checkprob renvoie true
- Si les deux probabilités sont différentes,
checkprob renvoie la probabilité rationnelle.
julia> successes, trials = [2, 9, 4, 4, 5], [15, 11, 17, 19, 15];
julia> checkprob(successes, trials)
true
julia> successes, trials = [9, 8, 5, 4, 3], [22, 14, 19, 25, 18];
julia> checkprob(sucesses, trials)
12//7315
Exercice d'apprentissage
