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

2
00:00:00,310 --> 00:00:01,750
>> DAVID MALAN: Passiamo ora a bocca aperta.

3
00:00:01,750 --> 00:00:06,500
Si scopre nel mondo reale 1 diviso
da 10 è infatti 1/10, o 0,1.

4
00:00:06,500 --> 00:00:10,370
Ma in computer che hanno solo un numero finito
numero di bit con cui

5
00:00:10,370 --> 00:00:14,290
rappresentare i numeri, non si può sempre
rappresentare i numeri come 1/10 con

6
00:00:14,290 --> 00:00:15,500
precisione perfetta.

7
00:00:15,500 --> 00:00:18,640
In altre parole, i computer hanno talvolta
per effettuare chiamate di giudizio e non

8
00:00:18,640 --> 00:00:22,740
rappresentano necessariamente il numero
vogliono più precisamente si intende.

9
00:00:22,740 --> 00:00:27,020
>> Ad esempio, supponiamo che io torno in
questo programma e modificare il 0,1,

10
00:00:27,020 --> 00:00:32,073
oh, 0.28, indicando in tal modo che
Vorrei printf a printf per

11
00:00:32,073 --> 00:00:34,350
28 posti di precisione.

12
00:00:34,350 --> 00:00:39,330
Vediamo ora Salvare e compilare il programma,
questa volta con il make floats2.

13
00:00:39,330 --> 00:00:41,910
Eseguire con dot barra floats2.

14
00:00:41,910 --> 00:00:49,980
E, mio ​​Dio, questa volta non vedo 0.1,
ma 0.10000000, che è abbastanza

15
00:00:49,980 --> 00:00:51,070
bene finora.

16
00:00:51,070 --> 00:00:57,830
Ma poi, 14901161193847656250.

17
00:00:57,830 --> 00:00:58,880
>> Ebbene, che cosa sta succedendo?

18
00:00:58,880 --> 00:01:02,280
Beh, si scopre che un galleggiante è
tipicamente memorizzato all'interno di un computer

19
00:01:02,280 --> 00:01:03,500
con 32 bit.

20
00:01:03,500 --> 00:01:07,340
32 è ovviamente un numero finito, che
implica che si può rappresentare solo

21
00:01:07,340 --> 00:01:11,050
con 32 bit di un numero finito
dei valori in virgola mobile.

22
00:01:11,050 --> 00:01:14,980
Purtroppo, ciò significa che il
computer non può rappresentare tutti i possibili

23
00:01:14,980 --> 00:01:18,110
numeri in virgola mobile, o numeri reali,
che esistono nel mondo,

24
00:01:18,110 --> 00:01:19,980
perché ha solo tanti bit.

25
00:01:19,980 --> 00:01:23,940
>> E così ciò che il computer è apparentemente
fatto in questo caso è rappresentare 1/10 a

26
00:01:23,940 --> 00:01:26,880
il più vicino possibile galleggiante
valore del punto che si può.

27
00:01:26,880 --> 00:01:31,050
Ma se guardiamo, come abbiamo qui, a 28
decimali, si iniziano a vedere che

28
00:01:31,050 --> 00:01:31,970
imprecisione.

29
00:01:31,970 --> 00:01:34,480
Quindi questo è un problema
nessuna soluzione perfetta.

30
00:01:34,480 --> 00:01:38,060
Possiamo usare una doppia invece di un float,
che tende ad usare 64 bit come

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

32
00:01:39,410 --> 00:01:42,290
Ma, naturalmente, 64 è anche finita,
quindi il problema sarà

33
00:01:42,290 --> 00:01:43,630
rimangono anche con doppie.

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