Precision des calculs sur ordinateur ou calculette
I Quelques opérations ou calculs simples...
1) sur l'affectation pour le mathématicien :
quand il se définit un nombre , il est connu avec une précision infinie....
et des opérations simples (addition, soustraction, multiplication) sur des nombres connus avec une précision infinie donnera un résultat....
également infiniment précis ! par exemple il peut dire : soit x = 0,1 et y = 0,8
x + y = 0,9 x - y = - 0,7 x . y = 0,08 = 0,125 avec ordinateur :
ce n'est pas du tout ces résultats que l'on obtient...
Soit le programme TURBO PASCAL (Annexe 0):
on donne la valeur 0,1 à x et 0,8 à y..
et on fait calculer x + y , x -y, x . y et et les résultats ne sont pas aussi précis que ceux du mathématicien !
Conclusion : tous les calculs sur ordinateur se font avec une précision qui n'est pas infinie ! Tous les calculs sur ordinateur sont comme les mesures du physicien, ils se font avec une certaine erreur ... qui, nous allons le voir, n'est pas toujours négligeable !
2) sur l'associativité et la commutativité pour le mathématicien :
" x , " y z = = = = 1 avec ordinateur :
si on prend x = 1 et y = 10-20 => z = = 0 au lieu de 1 !
par contre z = = 1
Soit le programme TURBO PASCAL (Annexe 1):
on fait calculer z =
avec x = 1 et y qui vaut successivement 10-1, 10-2, 10-3, etc...
On observe que pour 10-18 , le resultat commence à être mauvais et au delà de 10-20 z = 0 au lieu de 1 !
conclusion temporaire : la commutativité de l'opération addition du mathématicien n'est donc pas valable sur ordinateur !
Autre façon de dire la même chose : on ne peut pas sur ordinateur faire les opérations dans n'importe quel ordre !
le puriste pourra dire que, dans l'exemple ci-dessus, on a fait addition et soustraction , l'informaticien répondra qu'une soustraction est
executée comme une addition.. sur un nombre négatif ! 3) système de deux équations à deux inconnues
pour le mathématicien :
soit le système d'équations : (1) a . x + b . y = c
(2) a' . x + b' . y = c'
si det = a . b' - b . a' = 0 => le système est indéterminé ou n'a pas de solution
si det = a . b' - b . a' ≠ 0
=> il y a deux solutions x = et y = avec ordinateur :
soit le système :
(1) 1 . x + 2 . y = 4
(2) 2 . x + (4 + 10-20). y = 8 + 10-20
qui a pour solutions x = 2 et y = 1
si on calcule det = a . b' - b . a' = (4 + 10-20) - 4 = 0 => le système est indéterminé !!
par contre si on échange l'ordre d'étude des deux équations (en gardant les mêmes formules du mathématicien !)
(1) 2 . x + (4 + 10-20). y = 8 + 10-20 (2) 1 . x + 2 . y = 4
si on calcule det = a . b' - b . a' = 4 - 4 - 10-20 = 10-20 ≠ 0 =>
le système n'est plus indéterminé !
Soit le programme TURBO PASCAL (Annexe 2):
on fait résoudre, avec les formules du mathématicien, le système : (1) 1 . x + 2 . y = 4
(2) 2 . x + (4 + ß). y = 8 + ß (qui, ß, admet pour solution x = 2 et y = 1 ! )
avec ß qui vaut successivement 10-1, 10-2, 10-3, etc...
det = a . b' - b . a' = (4 + ß) - 4
On voit qu'avec l'ordinateur, à partir de ß = 10-19 , le déterminant devient nul et le système est dégénéré alors que pour le mathematicien {x = 2 et y = 1} sont toujours solution du système !
Soit le deuxième programme TURBO PASCAL (Annexe 2 bis ):
on fait résoudre, avec les formules du mathématicien, le même système, mais en échangeant l'ordre des deux équations :
(1) 2 . x + (4 + ß). y = 8 + ß (2) 1 . x + 2 . y = 4
avec ß qui vaut encore successivement 10-1, 10-2, 10-3, etc...
det = a . b' - b . a' = 4 - 4 - ß
On voit le determinant n'est jamais nul et vaut justement - ß ! mais à partir de ß = 10-17 , la valeur de x devient farfelue
en effet x = =
2ß et 4 ß sont négligeables devant 16 si bien que le numérateur = 0 ! Un autre exemple :
Reprenons notre système d'équations initial : (1) 1 . x + 2 . y = 4
(2) 2 . x + (4 + 10-20). y = 8 + 10-20 qui a pour solutions x = 2 et y = 1
et soit le nouveau système dans lequel la première équation est
inchangée, mais la deuxième, les coefficients sont légèrement modifiés : (1) 1 . x + 2 . y = 4
(2) 1,999 . x + 4. y = 7,99
ce nouveau système a pour solution x = 10 et y = -3
C'est à dire qu'un toute petite modification des coefficients, entraine une grosse modification de la solution ! Si les calculs se faisaient avec une précision infinie, il n'y aurait pas de problème, l'ennui c'est que justement l'ordinateur n'opère pas ainsi. On dit qu'un tel système est mal conditionné !
Bien sûr, il y a des techniques pour pallier de tels ennuis mais...
Encore une fois, sur un calcul très simple, l'ordinateur sort des
résultats farfelus ! Encore un exemple, pour montrer qu'il faut rester sceptique ....
4) trinôme du second degré pour le mathématicien :
soit l'équation : a. x2 + b . x + c = 0
si ∆ = b2 - 4 . a . c ≥ 0 => cette équation a des racines x =
avec ordinateur :
soit le trinôme 10-10. x2 - 0,8 . x + 10-10 = 0
qui admet comme racines théoriques x1 = 8.109 et x2 = 1,25.10-10
on fait calculer les racines par ordinateur en utilisant les formules du mathématiciens
(programme TURBO PASCAL - Annexe 3) le programme sort :
x1 = 8.109 solution correcte
et x2 = 2,7105.10-10 solution totalement farfelue !
par contre si on fait calculer x2 par la formule x2 = la réponse est correcte !
A vrai dire le problème est toujours le même : quand on calcule x2 , on calcule 0,8 -
or,pour l'ordinateur, 4.10-20 est négligeable devant 0,82=0,64 de plus, pour l'ordinateur, ≠ 0,8 ! donc x2 ≠ 0 !
A ce point du cours, on peut retenir ici : attention aux calculs sur des opérandes d'ordre de grandeur très différent !
II Le codage des données en machine
L'ordinateur ne traite que des données écrites en binaire; si l'on veut que ces données représentent des nombres entiers, des réels, des caractères,etc..il est nécessaire de définir un code qui permette de faire la "traduction" entre la donnée effectivement traitée par
l'ordinateur et la signification de cette donnée pour l'utilisateur.
Nous supposons ici connues les conversions (base 2 <--> base 10 et base 2 <--> base 16)
1) les nombres entiers a) le binaire signé
considérons un ordinateur manipulant des mots-machine de 8 bits (chiffres binaires)
un mot machine peut donc prendre 28 = 256 valeurs par exemple toutes les valeurs comprises entre 0 et 255 ! Or, en arithmétique, on veut pouvoir manipuler des entiers signés (positifs ou négatifs). Pour cela, on réserve donc le premier bit pour représenter le signe :
b7 b6 b5 b4 b3 b2 b1 b0
bit de signe
mantisse
avec 0 si positif et 1 si négatif dans le premier bit (ou le contraire !)
on peut ainsi représenter les nombres compris entre -128 et +127 soit toujours 255 valeurs possibles !
b) les nombres positifs - 0 dans le premier bit
- les autres bits correspondant à la conversion du nombre en binaire
exemple : (+ 105)10 = 01101001
pour des nombres supérieurs à 127, il faut coder sur plusieurs mots machine !
c) les nombres négatifs - 1 dans le premier bit
- les autres bits correspondant au complément à 2 de la conversion de l'opposé du nombre en binaire
exemple : (- 105)10 = ?
(105)10 = (1101001)2 et Complement2(1101001)2 = (0010111)2 d'où (- 105)10 = 10010111
que représente le mot machine 10111011 ? - premier bit : le signe ici négatif - 0111011 - 1 = (0111010)2
puis complémentation (1000101)2= (69)10 donc 10111011 = (- 69)10
Pourquoi codifier les nombres entiers négatifs en passant par le complément à 2 ?
Tout simplement pour avoir un seul traitement de l'addition et de la soustraction, en effet on a :
avec x et y ≥ 0
par ailleurs on peut considérer que : x - y = x + (-y) !
il suffit donc que (-y)2, soit représenté par Complement2(y)2 pour qu'il y ait parfaite correspondance ! 2) les nombres réels
Tous les calculs infra sont relatifs à la version Turbo Pascal sur MACINTOSH : pour d'autres versions , il suffit de consulter la documentation spécifique (nombre de bits d'exposant, de mantisse, etc....) mais le principe des calculs reste entièrement valable!
Raisonnons tout d'abord dans le système décimal :
un nombre réel peut s'écrire sous différentes formes, par exemple :
126,245 = 1,26245.102 = 12,6245.101 = 0,126245.103 = 1262,45.10-1 = etc..
ces écritures s'appèlent :'écriture en virgule flottante' ou 'ecriture scientifique'
Comme on le voit, un même nombre ayant différentes écritures possibles, il est nécessaire de privilégier une ecriture :
en informatique , en général, on privilégie l'écriture
0,126245.103( forme virgule flottante normalisée) dans laquelle : - la partie entière du nombre est nulle
- et le premier chiffre après la virgule est différent de 0 ! La connaissance d'un nombre nécessite 3 informations :
- le signe du nombre - sa mantisse
- son exposant (signé !)
0, 1 2 6 2 4 5 . 10
3 exposant mantisse
signe
en forme virgule flottante normalisée décimale, on a 0 ≤ mantisse <
1
On remarquera que pour le mathématicien l'ensemble des réels est un ensemble infini mais surtout continu , c'est à dire qu'entre deux réels, on peut toujours trouver un autre réel ! Par contre sur ordinateur, on ne peut étudier qu'un sous ensemble des réels (en étendue !) discontinu c'est à dire qu'entre deux nombres consécutifs ( le vocable 'consécutif' est pour le mathématicien une hérésie puisque l'ensemble des réels n'est pas dénombrable !) il y a une différence qui de plus change suivant la zone du sous ensemble codé. Ceci provient du nombre limité de bits affecté respectivement à l'exposant et à la mantisse.
Illustrons cette idée sur un exemple simple, nous allons considérer un réel codé sur huitbits avec :
1 bit de signe
3 bits d'exposant (translaté de + 4 si bien que l'exposant varie entre -4 et + 3)
4 bits de mantisse
le nombre étant écrit en écriture normalisée : (-1)s 0,1... 2exp On voit qu'alors :
le plus grand nombre positif sera donc :
(0,1111 .23)2 = 8 x (0,5 + 0,25 + 0,125 + 0,0625) = 7,5 le plus petit nombre positif sera donc :
(0,1000 .2-4)2 = x 0,5 = 0,03125
la différence entre deux réels consécutifs correspond à un bit de mantisse soit 0,0625 multiplié par la puissance de 2 correspondante :
soit ∆ = 0,0625 x 2exp
=> ∆max = 0,0625 x 23= 0,5 et ∆min = 0,0625 x 2-4= 0,00390625 pour le détail voir Annexe 4
en Turbo PASCAL, les réels (REAL) sont codés sur 32 bits, dans
lesquels on retrouve ces trois informations, sauf que le système de numération est de base 2:
soit donc des nombres de la forme : ± mantisse . 2exposant en Turbo Pascal, la mantisse a un unique bit à gauche de la virgule (1 ≤ mantisse < 2)
(attention, ceci ne correspond pas à l'écriture virgule flottante normalisée décimale !)
codés sous la forme :
<---32 bits--->
...
1° bit <---8 bits---> <--- 23 bits --->
pour le signe s pour l'exposant e pour la mantisse m
la valeur maximale de l'exposant est 28 - 1 = 255
à vrai dire l'exposant réel correspond à un translation sur e de telle façon à avoir des exposant positifs et négatifs entre -126 et + 127
la documentation Turbo Pascal donne :
si 0< e < 255 alors n = (-1)s x 2(e-127) x (1,m) si e=0 et m ≠ 0 alors n = (-1)s x 2(e-126) x (0,m) si e=0 et m = 0 alors n = (-1)s x 0
si e=255 et m ≠ 0 alors n = NAN (erreur !) si e=255 et m ≠ 0 alors n = (-1)s x 8
exemple :
soit le nombre 13 en base 10 : (13)10 = (1101)2
en base 2, écriture Turbo Pascal, il sera donc écrit 1,101 . 23
soit la représentation :
... que des zéros ensuite
1° bit <---8 bits---> <--- 23 bits --->
pour le signe pour l'exposant pour la mantisse m e = 3 + 127
on voit donc que :
le plus grand nombre positif représentable est :
max_positif = + 1,111...111. 2+127 avec 23 '1' après la virgule !
or 1,11... = 1+ 1 x 2-1 + 1 x 2-2 + ...
+ 1 x 2-23
= = 2 - 2-23
donc max_positif = (2 - 2-23 ). 2+127 = 3,403 . 10+38 le plus petit nombre positif représentable est :
min_positif = 1 . 2-126 = 1,175 . 10-38
quand Turbo PASCAL utilise la forme équivalente de la forme virgule flottante normalisée décimale (écriture dénormalisée dans la
documentation PASCAL)
le plus petit nombre positif dénormalisé(Turbo Pascal) représentable est :
min_positif_dénormalisée = 0,00000....1 . 2-126 (22 zéros après la virgule !)
= 2-23 . 2-126= 2-149 = 1,401 . 10-45
On voit tout de suite d'après les calculs ci-dessus que : - l'éventail des nombres représentables en ordinateur - la précision des ces nombres
dépend du nombre de bits sur lequel est codé le nombre réel
type taille(bits) intervalle de l'exposant minimum maximum précision de la mantisse bits (avec signe ) chiffres décimaux échelle décimale min negatif max neg norm max neg denorm
max positif min pos norm min posit denorm
REAL 32
-126 127
24 7-8 -3,4.10+38
-1,2.10-38 -1,5.10-45 3,4.10+38 1,2.10-38 1,5.10-45
DOUBLE 64
-1022 1023
53 15-16 -1,7.10+308
-2,3.10-308 -5,0.10-324 1,7.10+308 2,3.10-308 5,0.10-324
COMP 64
- -
63 18-19 -9,2.10+18
EXTENDED 80
-16383 16384
64 19-20 -1,1.10+4932
-1,7.10-4932 -1,9.10-4951 1,1.10+4932 1,7.10-4932 1,9.10-4951
le détail des calculs de ces caractéristiques est en annexe 3) les opérations arithmétiques sur les nombres réels
Pour faciliter la compréhension des opérations sur les réels, nous allons considérer des nombres codés en numération décimale -donc sur un ordinateur fictif !- et pas en binaire :
nous allons de nouveau considérer notre réel codé sur huit chiffres avec :
1 chiffre de signe 3 chiffres d'exposant 4 chiffres de mantisse
le nombre étant écrit en écriture normalisée : (-1)s 0,1... 10exp
soit <---8 symboles--->
S <---E---><---M---->
Soient donc deux nombres x et y; ces deux nombres sont connus par - Sx et Sy les signes de x et y
- Ex et Ey les exposants de x et y majorés de 500
(si bien que les exposant peuvent varier entre -500 et + 499 !)
- Mx et My les mantisses de x et y
a) l'addition et la soustraction (ces deux opérations sont traités identiquement cf supra)
ces opérations se font en plusieurs étapes :
) l'exposant le plus petit est amené à la valeur du plus grand;
ceci a pour effet de "dénormaliser" le nombre le plus petit... et d'introduire des zéros à gauche
) les mantisses sont ensuite additionnées ou retranchées
) si nécessaire une phase de "renormalisation" s'ensuit exemple 1 :
soient x = 3,14159 y = +51,126
mathématiquement S = x + y = 54,26759 sur l'ordinateur fictif :
x
y il y a perte de décimales pour x et y ! modification de x le plus petit :
x perte de nouveaux chiffres significatifs!
S
<---8 chiffres --->
après troncature S = soit +54,26 au lieu de 54,26759
exemple 2 :
soient x = 3,14159 y = +51126
mathématiquement S = x + y = 51129,14159 sur l'ordinateur fictif :
x
y y = 51120 au lieu de 51126 ! modification de x le plus petit :
x x = 0 !!!
S
<---8 chiffres --->
après troncature S = soit +51120 au lieu de 51129,14159
exemple 3 :
soient x = 3,14159 y = 3,14
mathématiquement D = x - y = 0,00159 sur l'ordinateur fictif :
x y D
<---8 chiffres --->
après renormalisation et troncature :
D donc D = 0,001000 au lieu de 0,00159
la soustraction a donc introduit 3 zeros derrière le 1 après renormalisation qui n'ont aucune signification !!!
b) la multiplication
Soit P = x * y ; P est obtenu par les opérations suivantes : SP = Sx * Sy (règles des signes)
EP = Ex + Ey - 500
MP = Mx * My calculé sur 8 chiffres (le double de la longueur!) et alors deux cas peuvent se présenter :
) MP [0,1 1[ et le résultat est normalisé, on tronque les 4 derniers chiffres!
) MP [0,01 0,1[ le résultat n'est pas normalisé, il faut alors :
- décaler d'une position le produit des mantisses - retrancher 1 à l'exposant Ep
- tronquer les 4 derniers chiffres exemple 1 :
soient x = 3,14159 y = - 51,126
mathématiquement P = x * y = - 160,6169303 sur l'ordinateur fictif :
x
y il y a perte de décimales pour x et y ! P
<---8 chiffres --->
après troncature P=
soit - 160,5 au lieu de - 160,6169303
exemple 2 :
soient x = 1,414 y = 51,126
mathématiquement P = x * y = 72,292164 sur l'ordinateur fictif :
x
y il y a perte de décimales pour x et y ! P
<---8 chiffres ---> mais la mantisse n'est pas normalisée
=> décalage, décrémentation de l'exposant et troncature
=> P soit 72,28 au lieu de +72,292164
c
) la divisionSoit Q = ; Q est obtenu par les opérations suivantes : SP = Sx * Sy (règles des signes)
EQ = Ex - Ey + 500
MQ = calculé sur 8 chiffres (le double de la longueur!) et alors deux cas peuvent se présenter :
) MP [0,1 1[ et le résultat est normalisé, on tronque les 4 derniers chiffres!
) MP [0,1 1[ le résultat n'est pas normalisé, il faut alors renormaliser
exemple 1 :
soient x = 3,14159 y = 51,126
mathématiquement Q = = 0,06144799124 sur l'ordinateur fictif :
x
y il y a perte de décimales pour x et y ! Q
<---8 chiffres --->
après renormalisation Q =
En conclusion, nous pouvons dire que toutes les opérations arithmétiques simples et à fortiori, tous les calculs plus compliqués qui sont
nécessairement des combinaisons de ces quatre opérations se font OBLIGATOIREMENT avec une certaine précision !
codés sous la forme :
<---n_total bits--->
...
1° bit <---n_expo bits---> <--- n_mantisse bits --->
pour le signe pour l'exposant pour la mantisse
sauf pour le type COMP où tous les bits représente la complémentation à 2 du nombre !
le plus grand nombre positif représentable est :
max_positif = + 1,111...111. 2+(2(n_expo -1)-1)
avec n_mantisse '1' après la virgule
!
or 1,11. = 1+ 1 x 2-1 + 1 x 2-2 + ...+ 1 x 2- n_mantisse
= = 2 - 2-n_mantisse donc
n_mantisse n_expo max_pos max_pos
SINGLE 23 8 (2 - 2-23 ). 2+(27-1) 3,40. 10+38 DOUBLE 52 11 (2 - 2-52 ). 2+(210-1) 1,79. 10+308
COMP 63 - 2+63 -1 9,22. 10+18
EXTENDED 63 15 (2 - 2-63 ). 2+(214-1) 1,1. 10+4932
avec 27 -1 = 127 210 -1 = 1023 214 -1 = 16384 le plus petit nombre positif représentable est :
n_mantisse n_expo min_positif min_positif
SINGLE 23 8 2-(27-2) 1,17. 10-38
DOUBLE 52 11 2-(210-2) 2,22. 10-308
EXTENDED 63 15 2-(214-2) 1,7. 10-4932
avec 27 -2 = 126 210 -1 = 1022 214 -1 = 16383
quand Turbo PASCAL utilise la forme équivalente de la forme virgule flottante normalisée décimale (écriture dénormalisée dans la
documentation PASCAL)
le plus petit nombre positif dénormalisé(Turbo Pascal) représentable est :
min_positif_dénormalisée = 0,00000....1 . 2-(2(n_pos-1)-2) avec (n_mantisse-1) zéros après la virgule !
n_mantisse n_expo min_pos_denorm min_pos_denorm
SINGLE 23 8 2-23.2-(27-2) 1,4. 10-45
DOUBLE 52 11 2-52 .2-(210-2) 4,94. 10-324
EXTENDED 63 15 2-63 .2-(214-2) 1,9. 10-4951 avec 27 -2 = 126 210 -1 = 1022 214 -1 = 16383 donc 2-23.2-(27-2)=2-149 2-52.2-(210-2)=2-1074 2-63.2-(214-2)= 2-16446
Applications aux calculs numériques utiles au physicien:
I La régression linéaire
Considérons un ensemble de N couples de valeurs mesurées (xi,yi) de deux grandeurs a priori liées par une loi linéaire de la forme y = a . x + b La régression linéaire qui consiste à déterminer les coefficients a et b à partir des N couples de valeurs mesurées est la résolution d'un
système de deux équations à deux inconnnues obtenues en cherchant à minimiser J =
=> a =et b =
prenons un exemple : considérons la loi y = 108. x -108 et suppsons que l'on ait les points expérimentaux : {(1,0) , (1.00000001,1) (1.00000002,2) (1.00000003,3}
ces points vérifient parfaitement la loi théorique...
et pourtant quand on execute un programme de regression linéaire, il y a problème en effet :
N.= 4(1 +(1+10-8)2 +(1+2.10-8)2+(1+3.10-8)2)=4(1+ 12.10-8+13.10-16) et ()2 = (4+ 6.10-8)2 dans les deux cas sur ordinateur les petites termes sont négligés
avec la précision des calcul sur ordinateur => N.- ()2 =0 !!!!
alors que les points expérimentaux vérifiaient parfaitement la loi ! Exercice : on peut envisager la loi y = 10n. x -10n
et considérer les points expérimentaux
{(1,0) (1+10n,1) (1+2. 10n,2) (1+3.10n,3)} qui vérifient parfaitement la loi !
On peut chercher à partir de quelle valeur de n , les valeurs de a et b obtenues par regression linéaire posent problème
Sur CASIO decrochage à n = 7
En Turbo Pascal, cela dépend evidemment du mode de codage du réel (REAL, DOUBLE, EXTENDED)
Annexe 0 :
program affectation;
var x,y,z,t, u :real;
begin x := 0.1;
y := 0.8;
writeln('x vaut : ',x:20);
writeln('y vaut : ',y:20);
writeln;
writeln('x + y vaut : ',x+y:20);
writeln('x - y vaut : ',x-y:20);
writeln('x * y vaut : ',x*y:20);
writeln('x/y vaut : ',x/y:20);
readln;
end.
Annexe 1 :
program calcul_simple;
var x,y:real;
n:integer;
begin
(*affectation des valeurs*) x:=1; y:=1e-1;
writeln('y',' ':20,'valeurs REAL':20);
for n := 1 to 23 do begin
writeln(y,' ':20,((x+y)-x)/y:3);
y:=y/10;
end;
readln;
end.
Annexe 2 :
(* on se propose de résoudre le systeme : 1 x + 2 y = 4
2 x + (4+ ß) y = 8 + ß avec ß =1e-1,1e-2,etc... *) var beta,det :real;
n :integer;
begin
beta:=1e-1;
writeln('beta',' ':17,'x',' ':20,'y',' ':20);
for n:=1 to 23 do begin
det:= (4+ beta)-4;
if det = 0
then writeln(beta,'determinant nul !':60) else writeln(beta,' ':10,
(4*(4+beta)-2*(8+beta))/det,' ':10,((8+beta)-8)/det);
beta:=beta/10;
end;
readln;
end.
Annexe 3 :
program trinome;
var a,b,c,x1:real;
begin
writeln('entrez les coeeficients du trinome : ');
write('a : ');readln(a);write('b : ');readln(b); write('c : ');readln(c);
if (b*b - 4*a*c) <0
then writeln('votre trinome n''a pas de racine !') else if (b*b - 4*a*c) = 0
then writeln(' votre trinome a une racine double : ',-b/(2*a)) else begin
x1:=(-b + sqrt(b*b - 4*a*c))/(2*a);
writeln(' votre trinome a deux racines : ');
writeln(' premiere racine : ',x1:13);
writeln(' deuxieme racine : ',(-b - sqrt(b*b - 4*a*c))/(2*a):13,'formule habituelle');
writeln(' deuxieme racine : ', c/(a*x1):13,'formule du produit des racines');
end;
readln;
end.
Annexe 4 :
1 bit de signe, 3 bits d'exposant, 4 bits de mantisse
contenu du valeur décimale valeur décimale différence mot mémoire de l'exposant de la mantisse du mot mémoire
01111111 3 0,9375 7,5
01111110 3 0,875 7 0,5
01111101 3 0,8125 6,5 0,5
01111100 3 0,75 6 0,5
01111011 3 0,6875 5,5 0,5
01111010 3 0,625 5 0,5
01111001 3 0,5625 4,5 0,5
01111000 3 0,5 4 0,5
01101111 2 0,9375 3,75 0,25
01101110 2 0,875 3,5 0,25
01101101 2 0,8125 3,25 0,25
01101100 2 0,75 3 0,25
01101011 2 0,6875 2,75 0,25
01101010 2 0,625 2,5 0,25
01101001 2 0,5625 2,25 0,25
01101000 2 0,5 2 0,25
01011111 1 0,9375 1,875 0,125
01011110 1 0,875 1,75 0,125
01011101 1 0,8125 1,625 0,125
01011100 1 0,75 1,5 0,125
01011011 1 0,6875 1,375 0,125
01011010 1 0,625 1,25 0,125
01011001 1 0,5625 1,125 0,125
01011000 1 0,5 1 0,125
01001111 0 0,9375 0,9375 0,0625
01001110 0 0,875 0,875 0,0625
01001101 0 0,8125 0,8125 0,0625
01001100 0 0,75 0,75 0,0625
01001011 0 0,6875 0,6875 0,0625
01001010 0 0,625 0,625 0,0625
01001001 0 0,5625 0,5625 0,0625
01001000 0 0,5 0,5 0,0625
contenu du valeur décimale valeur décimale différence mot mémoire de l'exposant de la mantisse du mot mémoire
00111111 -1 0,9375 0,46875 0,03125
00111110 -1 0,875 0,4375 0,03125
00111101 -1 0,8125 0,40625 0,03125
00111100 -1 0,75 0,375 0,03125
00111011 -1 0,6875 0,34375 0,03125
00111010 -1 0,625 0,3125 0,03125
00111001 -1 0,5625 0,28125 0,03125
00111000 -1 0,5 0,25 0,03125
00101111 -2 0,9375 0,234375 0,015625
00101110 -2 0,875 0,21875 0,015625
00101101 -2 0,8125 0,203125 0,015625
00101100 -2 0,75 0,1875 0,015625
00101011 -2 0,6875 0,171875 0,015625
00101010 -2 0,625 0,15625 0,015625
00101001 -2 0,5625 0,140625 0,015625
00101000 -2 0,5 0,125 0,015625
00011111 -3 0,9375 0,1171875 0,0078125
00011110 -3 0,875 0,109375 0,0078125
00011101 -3 0,8125 0,1015625 0,0078125
00011100 -3 0,75 0,0937 0,0078125.
00011011 -3 0,6875 0,0859375 0,0078125
00011010 -3 0,625 0,078125 0,0078125
00011001 -3 0,5625 0,0703125 0,0078125
00011000 -3 0,5 0,0625 0 ,0078125
00001111 -4 0,9375 0,05859375 0,00390625
00001110 -4 0,875 0,0546875 0,00390625
00001101 -4 0,8125 0,05078125 0,00390625
00001100 -4 0,75 0,046875 0,00390625
00001011 -4 0,6875 0,04296875 0,00390625
00001010 -4 0,625 0,0390625 0,00390625
00001001 -4 0,5625 0,03515625 0,00390625
00001000 -4 0,5 0,03125 0,00390625
00000000 0 0 0
10000000 0 -0
10001000 -4 0,5 -0,03125 0,00390625
10001001 -4 0,5625 -0,03515625 0,00390625
et cela continue dans les négatifs (symétriquement aux posititifs) jusque..
....
...11111111 3 0,9375 -7,5
Annexe 5 :
program regression_lineaire;
const nmax=100;
var n,i:integer; (*nombre de mesures*) x:array[1..nmax] of real;
y:array[1..nmax] of real; (* tableau pour stocker les coordonnées*) det,s_x,s_carre_x,s_y,s_xy,a,b:real;
rep:char;
begin i:= 1;
(*saisie des coordonnées des points*) rep:='o';
while (rep in ['o','O']) and (i < nmax) do begin
write('abscisse du point ',i:2,' : ');readln(x[i]);
write('ordonnée du point ',i:2,' : ');readln(y[i]);
write('on continue ? (o/n) ');readln(rep);
i:=i+1;
end;
n:=i-1;
(*calcul des coefficients de la regression *) s_x:=0;s_carre_x:=0;s_y:=0;s_xy:=0;
for i:= 1 to n do begin
s_x:=s_x+x[i];
s_carre_x:=s_carre_x + x[i] * x[i];
s_y:=s_y + y[i];
s_xy:=s_xy+ x[i]*y[i];
end;
det:= n* s_carre_x - s_x * s_x;
if det = 0
then writeln ('votre systeme n''a pas de solution') else begin
writeln('la pente a est : ',(n*s_xy-s_x*s_y)/det:20);
writeln('le coeff b est : ',(s_y*s_carre_x-s_xy*s_x)/det:20);
end;
readln;
end.
