1
00:00:00,000 --> 00:00:00,310

2
00:00:00,310 --> 00:00:01,750
>> DAVID Malan: Voyons maintenant souffler votre esprit.

3
00:00:01,750 --> 00:00:06,500
Il s'avère dans le monde réel 1 divisé
par 10 est en effet 1/10, ou 0,1.

4
00:00:06,500 --> 00:00:10,370
Mais dans les ordinateurs qui ont seulement un fini
nombre de bits avec lequel

5
00:00:10,370 --> 00:00:14,290
représenter des nombres, vous ne pouvez pas toujours
représenter des nombres comme 1/10 avec

6
00:00:14,290 --> 00:00:15,500
une précision parfaite.

7
00:00:15,500 --> 00:00:18,640
En d'autres termes, les ordinateurs ont parfois
à faire preuve de jugement et de ne pas

8
00:00:18,640 --> 00:00:22,740
représentent pas nécessairement le numéro que vous
veulent aussi précisément que vous avez l'intention.

9
00:00:22,740 --> 00:00:27,020
>> Par exemple, supposons que je retourne dans
ce programme et changer l'0,1 à,

10
00:00:27,020 --> 00:00:32,073
oh, 0,28, ce qui indique que
J'aimerais printf à printf à

11
00:00:32,073 --> 00:00:34,350
28 places de précision.

12
00:00:34,350 --> 00:00:39,330
Voyons maintenant enregistrer et compiler le programme,
cette fois avec la marque floats2.

13
00:00:39,330 --> 00:00:41,910
Lancez-le avec le point barre floats2.

14
00:00:41,910 --> 00:00:49,980
Et, mon Dieu, cette fois, je vois pas 0,1,
mais 0.10000000, ce qui est assez

15
00:00:49,980 --> 00:00:51,070
bon jusqu'ici.

16
00:00:51,070 --> 00:00:57,830
Mais alors, 14901161193847656250.

17
00:00:57,830 --> 00:00:58,880
>> Eh bien, ce qui se passe?

18
00:00:58,880 --> 00:01:02,280
Eh bien, il s'avère que le flotteur est
typiquement stocké à l'intérieur d'un ordinateur

19
00:01:02,280 --> 00:01:03,500
avec 32 bits.

20
00:01:03,500 --> 00:01:07,340
32 est évidemment un nombre fini, qui
implique que vous ne pouvez représenter

21
00:01:07,340 --> 00:01:11,050
32 bits avec un nombre fini d'
des valeurs en virgule flottante.

22
00:01:11,050 --> 00:01:14,980
Malheureusement, cela signifie que l'
ordinateur ne peut pas représenter possible

23
00:01:14,980 --> 00:01:18,110
nombres à virgule flottante, ou des nombres réels,
qui existe dans le monde entier,

24
00:01:18,110 --> 00:01:19,980
car il ne dispose que de nombreux bits.

25
00:01:19,980 --> 00:01:23,940
>> Et si ce que l'ordinateur est apparemment
faire dans ce cas est de représenter 1/10 à

26
00:01:23,940 --> 00:01:26,880
le flottant le plus proche possible
valeur du point qu'il peut.

27
00:01:26,880 --> 00:01:31,050
Mais si nous regardons, que nous avons ici, au 28
décimales, nous commençons à voir que

28
00:01:31,050 --> 00:01:31,970
imprécision.

29
00:01:31,970 --> 00:01:34,480
C'est donc un problème avec
pas de solution parfaite.

30
00:01:34,480 --> 00:01:38,060
Nous pouvons utiliser un double au lieu d'un flotteur,
qui tend à utiliser 64 bits comme

31
00:01:38,060 --> 00:01:39,410
contre 32.

32
00:01:39,410 --> 00:01:42,290
Mais bien sûr, 64 est aussi fini,
de sorte que le problème sera

33
00:01:42,290 --> 00:01:43,630
rester, même avec des doubles.

34
00:01:43,630 --> 00:01:46,323