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

2
00:00:00,310 --> 00:00:01,750
>> DAVID MALAN: Vamos agora explodir sua mente.

3
00:00:01,750 --> 00:00:06,500
Acontece que no mundo real 1 dividido
por 10 é efectivamente 1/10, ou 0,1.

4
00:00:06,500 --> 00:00:10,370
Mas, em computadores que só tem um finito
número de bits com o qual

5
00:00:10,370 --> 00:00:14,290
representar números, você não pode sempre
representar números como 1/10 com

6
00:00:14,290 --> 00:00:15,500
precisão perfeita.

7
00:00:15,500 --> 00:00:18,640
Em outras palavras, por vezes, têm computadores
para fazer chamadas de julgamento e não

8
00:00:18,640 --> 00:00:22,740
representam, necessariamente, o número que
quero tão precisamente quanto você pretende.

9
00:00:22,740 --> 00:00:27,020
>> Por exemplo, suponha que eu volte para
este programa e alterar a 0,1 e,

10
00:00:27,020 --> 00:00:32,073
oh, 0,28, o que indica que
Eu gostaria printf para printf para

11
00:00:32,073 --> 00:00:34,350
28 locais de precisão.

12
00:00:34,350 --> 00:00:39,330
Vamos agora salvar e compilar o programa,
desta vez com make floats2.

13
00:00:39,330 --> 00:00:41,910
Execute-o com um ponto floats2 barra.

14
00:00:41,910 --> 00:00:49,980
E, meu Deus, desta vez eu não ver 0,1,
mas 0.10000000, que é bastante

15
00:00:49,980 --> 00:00:51,070
bom até agora.

16
00:00:51,070 --> 00:00:57,830
Mas então, 14901161193847656250.

17
00:00:57,830 --> 00:00:58,880
>> Bem, o que está acontecendo?

18
00:00:58,880 --> 00:01:02,280
Bem, acontece que um float é
tipicamente armazenados dentro de um computador

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

20
00:01:03,500 --> 00:01:07,340
32 é, obviamente, um número finito, que
implica que você só pode representar

21
00:01:07,340 --> 00:01:11,050
com 32 bits um número finito
de valores de ponto flutuante.

22
00:01:11,050 --> 00:01:14,980
Infelizmente, isto significa que o
computador não pode representar todos os possíveis

23
00:01:14,980 --> 00:01:18,110
números de ponto flutuante, ou números reais,
que existem no mundo,

24
00:01:18,110 --> 00:01:19,980
porque só tem tantos bits.

25
00:01:19,980 --> 00:01:23,940
>> E assim que o computador é aparentemente
feito neste caso é representar 1/10 a

26
00:01:23,940 --> 00:01:26,880
o mais próximo possível flutuante
valor do ponto que ele pode.

27
00:01:26,880 --> 00:01:31,050
Mas se olharmos, como nós temos aqui, a 28 de
casas decimais, começamos a ver que

28
00:01:31,050 --> 00:01:31,970
imprecisão.

29
00:01:31,970 --> 00:01:34,480
Portanto, este é um problema com
nenhuma solução perfeita.

30
00:01:34,480 --> 00:01:38,060
Podemos usar um casal em vez de um carro alegórico,
que tende a usar 64 bits como

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

32
00:01:39,410 --> 00:01:42,290
Mas, claro, 64 também é finito,
então o problema vai

33
00:01:42,290 --> 00:01:43,630
permanecem mesmo com duplos.

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