Matemática Numérica I

1 Aritmética de Máquina 1.1 Sistema de Numeração Posicional 1.3 Notação Científica e Arredondamento

Ajude a manter o site livre, gratuito e sem propagandas. Colabore!

1.2 Representação de Números em Máquina

Usualmente, números são manipulados em máquina através de suas representações em registros com $n$ -bits. Ao longo desta seção, vamos usar a seguinte notação

[b_{1}\leavevmode\nobreak\ b_{2}\leavevmode\nobreak\ b_{3}\leavevmode\nobreak% \ \cdots\leavevmode\nobreak\ b_{n}],

(1.30)

para representar um registro de $n$ -bits $b_{i}\in\{0,1\}$ , $i=1,2,\dotsc,n$ .

Na sequência, fazemos uma breve discussão sobre as formas comumente usadas para a manipulação de números em computadores.

1.2.1 Números Inteiros

O sistema de complemento de 2 é utilizado em computadores para a manipulação de números inteiros. Nesta representação, um registro de $n$ bits

[d_{1}\leavevmode\nobreak\ d_{2}\leavevmode\nobreak\ d_{3}\leavevmode\nobreak% \ \cdots\leavevmode\nobreak\ d_{n}],

(1.31)

representa o número inteiro

x=(d_{n-1}\leavevmode\nobreak\ \ldots\leavevmode\nobreak\ d_{2}\leavevmode% \nobreak\ d_{1})_{2}-d_{n}2^{n-1}.

(1.32)

Exemplo 1.2.1.

O registro de 8 bits²²endnote: ²8 bits = 1 byte [B].

[1\leavevmode\nobreak\ 1\leavevmode\nobreak\ 0\leavevmode\nobreak\ 0% \leavevmode\nobreak\ 0\leavevmode\nobreak\ 0\leavevmode\nobreak\ 0\leavevmode% \nobreak\ 0]

(1.33)

representa o número

$\displaystyle x$	$\displaystyle=-d_{8}\cdot 2^{8-1}+(d_{7}\leavevmode\nobreak\ d_{6}\leavevmode% \nobreak\ \ldots\leavevmode\nobreak\ d_{1})_{2}$	(1.34)
	$\displaystyle=-0\cdots 2^{7}+(\stackrel{{\scriptstyle 6}}{{0}}\leavevmode% \nobreak\ \stackrel{{\scriptstyle 5}}{{0}}\leavevmode\nobreak\ \stackrel{{% \scriptstyle 4}}{{0}}\leavevmode\nobreak\ \stackrel{{\scriptstyle 3}}{{0}}% \leavevmode\nobreak\ \stackrel{{\scriptstyle 2}}{{0}}\leavevmode\nobreak\ % \stackrel{{\scriptstyle 1}}{{1}}\leavevmode\nobreak\ \stackrel{{\scriptstyle 0% }}{{1}})_{2}$	(1.35)
	$\displaystyle=2^{1}+2^{0}=3.$	(1.36)

Podemos implementar um conversor de registro para número inteiro como segue

Código 1: packbits8.py

⬇

1def packBitsInt8(dd):

2 x = -dd[7] * 2**7

3 for i, d in enumerate(dd[:7]):

4 x += d * 2**(i)

5 return x

Esta função, converte uma lista de bits (registro) no inteiro corresponde ao sistema de complemento 2.

⬇

1packBitsInt8([1,1,0,0,0,0,0,0])

Na representação de complemento de 2 com $n$ bits, o menor e o maior números inteiros são obtidos com os registros

	$\displaystyle-2^{n-1}\sim[0\leavevmode\nobreak\ 0\leavevmode\nobreak\ 0% \leavevmode\nobreak\ 0\leavevmode\nobreak\ \cdots\leavevmode\nobreak\ 1],$		(1.37)
	$\displaystyle 2^{n-1}-1\sim[1\leavevmode\nobreak\ 1\leavevmode\nobreak\ 1% \leavevmode\nobreak\ \cdots\leavevmode\nobreak\ 1\leavevmode\nobreak\ 0],$		(1.38)

respectivamente. Já o zero é obtido com o registro

0\sim[0\leavevmode\nobreak\ 0\leavevmode\nobreak\ 0\leavevmode\nobreak\ 0% \leavevmode\nobreak\ 0\leavevmode\nobreak\ 0\leavevmode\nobreak\ 0\leavevmode% \nobreak\ 0].

(1.39)

Exemplo 1.2.2.

Com um registro de $8$ -bits, temos que o menor e o maior números inteiros que podem ser representados são

	$\displaystyle[0\leavevmode\nobreak\ 0\leavevmode\nobreak\ 0\leavevmode\nobreak% \ 0\leavevmode\nobreak\ 0\leavevmode\nobreak\ 0\leavevmode\nobreak\ 0% \leavevmode\nobreak\ 1]$		(1.40)
	$\displaystyle\sim-2^{7}+(0000000)_{2}=-128,$		(1.41)

	$\displaystyle[1\leavevmode\nobreak\ 1\leavevmode\nobreak\ 1\leavevmode\nobreak% \ 1\leavevmode\nobreak\ 1\leavevmode\nobreak\ 1\leavevmode\nobreak\ 1% \leavevmode\nobreak\ 0]$		(1.42)
	$\displaystyle\sim-0\cdot 2^{7}+(1111111)_{2}=127,$		(1.43)

respectivamente.

Usando o Código 1, temos

⬇

1packBitsInt8([0,0,0,0,0,0,0,1])

-128

⬇

1packBitsInt8([1,1,1,1,1,1,1,0])

⬇

1packBitsInt8([0,0,0,0,0,0,0,0])

Observação 1.2.1.

No NumPy, o dtype=numpy.int8 corresponde a inteiros de 8 bits.

⬇

1import numpy as np

2np.array([-127, 0, 3, 128, 129], dtype=np.int8)

array([-127,    0,    3, -128, -127], dtype=int8)

Consulte a lista de tipos básicos do NumPy em NumPy:Data types.

A adição de números inteiros na representação de complemento de 2 pode ser feita de maneira simples. Por exemplo, consideremos a soma $3+9$ usando registros de 8 bits. Temos

$\displaystyle 3$	$\displaystyle\sim[1\leavevmode\nobreak\ 1\leavevmode\nobreak\ 0\leavevmode% \nobreak\ 0\leavevmode\nobreak\ 0\leavevmode\nobreak\ 0\leavevmode\nobreak\ 0% \leavevmode\nobreak\ 0]$	(1.44)
$\displaystyle 9$	$\displaystyle\sim[1\leavevmode\nobreak\ 0\leavevmode\nobreak\ 0\leavevmode% \nobreak\ 1\leavevmode\nobreak\ 0\leavevmode\nobreak\ 0\leavevmode\nobreak\ 0% \leavevmode\nobreak\ 0]\leavevmode\nobreak\ +$	(1.45)
$\displaystyle-$	$\displaystyle--------$	(1.46)
$\displaystyle 12$	$\displaystyle\sim[0\leavevmode\nobreak\ 0\leavevmode\nobreak\ 1\leavevmode% \nobreak\ 1\leavevmode\nobreak\ 0\leavevmode\nobreak\ 0\leavevmode\nobreak\ 0% \leavevmode\nobreak\ 0]$	(1.47)

No sistema de complemento de 2, a representação de um número negativo $-x$ pode ser obtida da representação de $x$ , invertendo seus bits e somando 1. Por exemplo, a representação de $-3$ pode ser obtida da representação de $3$ , como segue

3\sim[1\leavevmode\nobreak\ 1\leavevmode\nobreak\ 0\leavevmode\nobreak\ 0% \leavevmode\nobreak\ 0\leavevmode\nobreak\ 0\leavevmode\nobreak\ 0\leavevmode% \nobreak\ 0].

(1.48)

Invertendo seus bits e somando 1, obtemos

-3\sim[1\leavevmode\nobreak\ 0\leavevmode\nobreak\ 1\leavevmode\nobreak\ 1% \leavevmode\nobreak\ 1\leavevmode\nobreak\ 1\leavevmode\nobreak\ 1\leavevmode% \nobreak\ 1].

(1.49)

A subtração de números inteiros usando a representação de complemento de 2 fica, então, tanto simples quanto a adição. Por exemplo:

$\displaystyle 3$	$\displaystyle\sim[1\leavevmode\nobreak\ 1\leavevmode\nobreak\ 0\leavevmode% \nobreak\ 0\leavevmode\nobreak\ 0\leavevmode\nobreak\ 0\leavevmode\nobreak\ 0% \leavevmode\nobreak\ 0]$	(1.50)
$\displaystyle-9$	$\displaystyle\sim[1\leavevmode\nobreak\ 1\leavevmode\nobreak\ 1\leavevmode% \nobreak\ 0\leavevmode\nobreak\ 1\leavevmode\nobreak\ 1\leavevmode\nobreak\ 1% \leavevmode\nobreak\ 1]\leavevmode\nobreak\ +$	(1.51)
$\displaystyle-$	$\displaystyle--------$	(1.52)
$\displaystyle-6$	$\displaystyle\sim[0\leavevmode\nobreak\ 1\leavevmode\nobreak\ 0\leavevmode% \nobreak\ 1\leavevmode\nobreak\ 1\leavevmode\nobreak\ 1\leavevmode\nobreak\ 1% \leavevmode\nobreak\ 1]$	(1.53)

1.2.2 Ponto Flutuante

A manipulação de números decimais em computadores é comumente realizada usando a representação de ponto flutuante de 64 bits³³endnote: ³Padrão IEEE 754.. Nesta, um dado registro de 64 bits

[s\leavevmode\nobreak\ |\leavevmode\nobreak\ c_{10}\leavevmode\nobreak\ c_{9}% \leavevmode\nobreak\ \ldots\leavevmode\nobreak\ c_{0}\leavevmode\nobreak\ |% \leavevmode\nobreak\ m_{1}\leavevmode\nobreak\ m_{2}\leavevmode\nobreak\ % \ldots\leavevmode\nobreak\ m_{52}]

(1.54)

representa o número

x=(-1)^{s}M\cdot 2^{c-1023},

(1.55)

onde $M$ é chamada de mantissa e $c$ da característica, as quais são definidas por

	$\displaystyle M$	$\displaystyle:=(1,m_{1}m_{2}m_{3}\ldots m_{52})_{2},$		(1.56)
	$\displaystyle c$	$\displaystyle:=(c_{10}\ldots c_{2}c_{1}c_{0})_{2}.$		(1.57)

Exemplo 1.2.3.

Por exemplo, na representação em ponto flutuante de 64 bits, temos que o registro

[1\leavevmode\nobreak\ |\leavevmode\nobreak\ 1\leavevmode\nobreak\ 0% \leavevmode\nobreak\ \ldots\leavevmode\nobreak\ 0\leavevmode\nobreak\ 0% \leavevmode\nobreak\ |\leavevmode\nobreak\ 1\leavevmode\nobreak\ 0\leavevmode% \nobreak\ 1\leavevmode\nobreak\ 0\leavevmode\nobreak\ 0\leavevmode\nobreak\ % \ldots\leavevmode\nobreak\ 0]

(1.58)

representa o número $-3.25$ .

A seguinte função faz a conversão uma lista de 64 bits no número decimal corresponde ao sistema de ponto flutuante de 64 bits.

Código 2: packBitsDouble.py

⬇

1def packBitsDouble(ld):

2 s = ld[0]

3 c = 0

4 for i, d in enumerate(ld[1:12]):

5 c += d * 2**(10-i)

6 m = 1.

7 for i, d in enumerate(ld[12:]):

8 m += d * 2**(-(i+1))

9 x = m * 2**(c - 1023)

10 return -x if s else x

Por exemplo, usando-a para o registro acima, obtemos

⬇

1ld = [0]*14

2ld[0]=1

3ld[1]=1

4ld[12]=1

5ld[13]=1

6packBitsDouble(ld)

-3.5

1.2.3 Erro de Arredondamento

Dado um número real $x$ , sua representação $fl(x)$ em ponto flutuante é o registro que representa o número mais próximo de $x$ . Este procedimento é chamado de arredondamento por proximidade.

A seguinte função obtém a representação em ponto flutuante de 64 bits de um dado número $x$ ⁴⁴endnote: ⁴Esta função não é precisa e pode fornecer registros errados devido a erros de arredondamento. Uma alternativa melhor é apresentada na Observação 1.2.2..

Código 3: unpackBitsDouble.py

⬇

1import numpy as np

3def unpackBitsDouble(x):

4 ld = 64*[0]

5 if ( x == 0):

6 return ld

7 elif (x < 0):

8 ld [0] = 1

9 x = np.fabs(x)

10 c = int(np.log2(x) + 1023)

11 m = x/2**(c - 1023)

12 for i in range(11):

13 ld [11 - i] = c % 2

14 c //= 2

15 m -= 1

16 for i in range(52):

17 m *= 2

18 ld [12+ i] = int(m)

19 m %= 1

20 return ld

Por exemplo, $x=1.1$ é representado pelo registro

⬇

1ld = unpackBitsDouble(1.1)

2ld

[0, 0, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 0, 0, 0, 1,
1, 0, 0, 1, 1, 0, 0, 1,
1, 0, 0, 1, 1, 0, 0, 1,
1, 0, 0, 1, 1, 0, 0, 1,
1, 0, 0, 1, 1, 0, 0, 1,
1, 0, 0, 1, 1, 0, 0, 1,
1, 0, 0, 1, 1, 0, 1, 0]

que corresponde ao número

⬇

1flx = packBitsDouble(ld)

2print(f'{flx:1.51f}')

1.10000000000000008881784197
0012523233890533447265625

O erro de arredondamento é $|x-fl(x)|\approx 8.9\times 10^{-17}$ .

Observação 1.2.2.

O seguinte código é uma solução mais pythonica para obter-se o registro em ponto flutuante de 64 bits de $x=1.1$ .

⬇

1''.join(f'{c:08b}' for c in struct.pack('!d', 1.1))

’0011111111110001
1001100110011001
1001100110011001
1001100110011010’

Recomendamos consultar [4] para mais informações sobre a conversão eficiente de números decimais em pontos flutuantes.

Observemos que o erro de arredondamento varia conforme o número dado, podendo ser zero no caso de $x=fl(x)$ . Comumente, utiliza-se o épsilon de máquina como uma aproximação desse erro. O épsilon de máquina é definido como a distância entre o número 1 e seu primeiro sucessor em ponto flutuante. Temos

⬇

1ld = unpackBitsDouble(1)

2ld

[0, 0, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0]

⬇

1ld[63] = 1

2x = packBitsDouble(ld)

3x-1

2.220446049250313e-16

Ou seja, o épsilon de máquina é

\mathrm{eps}:=2^{-52}\approx 2.22\times 10^{-16}.

(1.59)

Observação 1.2.3.

O método numpy.finfo pode ser usado para obtermos várias informações sobre o sistema de números em ponto flutuante. Por exemplo, temos

⬇

1import numpy as np

2finfo = np.finfo(np.double)

3finfo.eps

2.220446049250313e-16

⬇

1finfo.min

-1.7976931348623157e+308

⬇

1finfo.max

1.7976931348623157e+308

A aritmética em ponto flutuante requer arredondamentos sucessivos de números. Por exemplo, a computação da soma de dois números dados $x$ e $y$ é feita a partir de suas representações em ponto flutuante $fl(x)$ e $fl(y)$ . Então, computa-se $z=fl(x)+fl(y)$ e o resultado é $fl(z)$ . Observe, inclusive que $fl(x+y)$ pode ser diferente de $fl(fl(x)+fl(y))$ . Por exemplo

⬇

10.1 + 0.2 == 0.3

False

1.2.4 Exercícios Resolvidos

ER 1.2.1.

No sistema de complemento 2 de 8 bits, forneça o registro que representa os seguintes números inteiros:

a)

1
b)

-1
c)

15
d)

-15

Resolução.

A seguinte função, obtém o registro de complemento 2 de 8-bits de um dado número inteiro x.

⬇

1def unpackBitsInt8(x):

2 ld = 8*[0]

3 if (x < 0):

4 ld[7] = 1

5 x += 2**(7)

6 for i in range(7):

7 ld[i] = x % 2

8 x //= 2

9 return ld

Usando-a, obtemos os seguintes resultados:

⬇

1# a) 1

2unpackBitsInt8(1)

[1, 0, 0, 0, 0, 0, 0, 0]

⬇

1# b) -1

2unpackBitsInt8(-1)

[1, 1, 1, 1, 1, 1, 1, 1]

⬇

1# c) 15

2unpackBitsInt8(15)

[1, 1, 1, 1, 0, 0, 0, 0]

⬇

1unpackBitsInt8(-15)

[1, 0, 0, 0, 1, 1, 1, 1]

ER 1.2.2.

Qual é o número decimal positivo mais próximo de zero que pode ser representado como um ponto flutuante de 64-bits. Também, forneça seu registro.

Resolução.

Um registro em ponto flutuante de 64-bits tem a forma

[s\leavevmode\nobreak\ |\leavevmode\nobreak\ c_{10}\leavevmode\nobreak\ c_{9}% \leavevmode\nobreak\ \ldots\leavevmode\nobreak\ c_{0}\leavevmode\nobreak\ |% \leavevmode\nobreak\ m_{1}\leavevmode\nobreak\ m_{2}\leavevmode\nobreak\ % \ldots\leavevmode\nobreak\ m_{52}]

(1.60)

e representa o número

x=(-1)^{s}M\cdot 2^{c-1023},

(1.61)

onde $M$ é chamada de mantissa e $c$ da característica, as quais são definidas por

	$\displaystyle M$	$\displaystyle:=(1,m_{1}m_{2}m_{3}\ldots m_{52})_{2},$		(1.62)
	$\displaystyle c$	$\displaystyle:=(c_{10}\ldots c_{2}c_{1}c_{0})_{2}.$		(1.63)

Tendo em vista que o registro nulo é reservado para o número decimal zero, temos que o número positivo mais próximo de zero é obtido com sinal $s=0$ , a mantissa $M=1$ e a característica $c=1$ , no que obtemos o decimal

	$\displaystyle x$	$\displaystyle=2^{-1022}$		(1.64)
		$\displaystyle\approx 2.2250738585072014e-308$		(1.65)

Seu registro é

[0\leavevmode\nobreak\ |\leavevmode\nobreak\ 0\leavevmode\nobreak\ 0% \leavevmode\nobreak\ \ldots\leavevmode\nobreak\ 1\leavevmode\nobreak\ |% \leavevmode\nobreak\ 0\leavevmode\nobreak\ 0\leavevmode\nobreak\ \ldots% \leavevmode\nobreak\ 0]

(1.66)

O resultado pode ser verificado com os seguintes comandos:

⬇

1import numpy as np

2import struct

3x = np.finfo(np.double).tiny; x

2.2250738585072014e-308

⬇

1''.join(f'{c:08b}' \

2 for c in struct.pack('!d', x))

’0000000000010000
0000000000000000
0000000000000000
0000000000000000’

ER 1.2.3.

Em aplicações que não necessitam de muita precisão, a representação de números decimais no sistema de ponto flutuante de 32 bits é mais eficiente (no sentido de velocidade de processamento computacional). Neste sistema, um registro de 32-bits

[s\leavevmode\nobreak\ |\leavevmode\nobreak\ c_{7}\leavevmode\nobreak\ c_{6}% \leavevmode\nobreak\ \ldots\leavevmode\nobreak\ c_{0}\leavevmode\nobreak\ |% \leavevmode\nobreak\ m_{1}\leavevmode\nobreak\ m_{2}\leavevmode\nobreak\ % \ldots\leavevmode\nobreak\ m_{23}]

(1.67)

representa o número

x=(-1)^{s}\cdot M\cdot 2^{c-127}

(1.68)

onde,

	$\displaystyle M=(1,m_{1}m_{2}\ldots m_{23})_{2}$		(1.69)
	$\displaystyle c=(c_{7}c_{6}\ldots c_{0})_{2}$		(1.70)

a)

Forneça o registro do ponto flutuante de 32-bits que representa o número $42.5$ .
b)

Qual é o sucessor em ponto flutuante de 32-bits do número decimal 1. Forneça, também, o épsilon de máquina deste sistema.

Resolução.

a)

O registro do ponto flutuante de 32-bits que representa o número $42.5$ pode ser computado com o seguinte código:

⬇

1x = 42.5

2ld = 32*[0]

3c = int(np.log2(x) + 127)

4m = x/2**(c-127)

5for i in range(8):

6 ld[8-i] = c % 2

7 c //= 2

8m -= 1

9for i in range(23):

10 m *= 2

11 ld[9+i] = int(m)

12 m %= 1

13ld
```
[0, 1, 0, 0, 0, 0, 1, 0,
0, 0, 1, 0, 1, 0, 1, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0]
```
Alternativamente, pode-se obter o registro como segue:

⬇

1''.join(f'{c:08b}' \

2for c in struct.pack('!f', 42.5))
```
’0100001000101010
0000000000000000’
```
b)

No sistema de ponto flutuante de 32-bits, o sucessor de 1 tem o registro

$[0\leavevmode\nobreak\ |\leavevmode\nobreak\ 0\leavevmode\nobreak\ 1% \leavevmode\nobreak\ 1\leavevmode\nobreak\ \ldots\leavevmode\nobreak\ 1% \leavevmode\nobreak\ |\leavevmode\nobreak\ 0\leavevmode\nobreak\ 0\leavevmode% \nobreak\ \ldots\leavevmode\nobreak\ 0\leavevmode\nobreak\ 1]$ (1.71)

donde, sua mantissa é $m=1+2^{-23}$ , característica $c=127$ e corresponde ao número decimal

$\displaystyle x=(-1)^{0}\cdot(1+2^{-23})\cdot 2^{127-127}$ (1.72)

$\displaystyle x=1+2^{-23}$ (1.73)

Portanto, o épsilon de máquina neste sistema é

$\displaystyle\mathrm{eps}$ $\displaystyle=x-1$ (1.74)

$\displaystyle=2^{-23}$ (1.75)

⬇

1np.float32(2**-23)
```
1.1920929e-07
```

1.2.5 Exercícios

E. 1.2.1.

Considerando a representação de complemento de 2 de números inteiros, obtenha os registros de $8$ -bits dos seguintes números:

a)

$17$
b)

$-17$
c)

$32$
d)

$-32$

a) [10001000]; b) [11110111]
c) [00000100]; d) [00000111]

E. 1.2.2.

Considerando a representação de complemento de 2 de números inteiros, obtenha os registros de $16$ -bits dos seguintes números:

a)

$1024$
b)

$-1024$

a) [0000000000100000];
b) [0000000000111111];

E. 1.2.3.

Considerando a representação de complemento de 2 de números inteiros, qual é o maior número que pode ser representado por um registro de $32$ -bits da forma

[1\leavevmode\nobreak\ 0\leavevmode\nobreak\ b_{2}\leavevmode\nobreak\ b_{3}% \leavevmode\nobreak\ b_{4}\leavevmode\nobreak\ \cdots\leavevmode\nobreak\ b_{3% 0}\leavevmode\nobreak\ 1],

(1.76)

onde $b_{i}\in\{0,1\}$ , $i=2,3,4,\cdots,30$ .

$[10111\ldots 11]\sim-3$

E. 1.2.4.

Obtenha os registros em ponto flutuante de $64$ -bits dos seguintes números:

a)

$-1.25$
b)

$3$

a) $[1\leavevmode\nobreak\ |\leavevmode\nobreak\ 0\leavevmode\nobreak\ 1% \leavevmode\nobreak\ 1\leavevmode\nobreak\ \ldots\leavevmode\nobreak\ 1% \leavevmode\nobreak\ |\leavevmode\nobreak\ 1\leavevmode\nobreak\ 0\leavevmode% \nobreak\ 1\leavevmode\nobreak\ 0\leavevmode\nobreak\ 0\leavevmode\nobreak\ % \ldots\leavevmode\nobreak\ 0]$ ;
b) $[0\leavevmode\nobreak\ |\leavevmode\nobreak\ 1\leavevmode\nobreak\ 0% \leavevmode\nobreak\ 0\leavevmode\nobreak\ \ldots\leavevmode\nobreak\ 0% \leavevmode\nobreak\ |\leavevmode\nobreak\ 1\leavevmode\nobreak\ 0\leavevmode% \nobreak\ 0\leavevmode\nobreak\ \ldots\leavevmode\nobreak\ 0]$

E. 1.2.5.

Assumindo o sistema de ponto flutuante de $32$ -bits, obtenha o registro e o erro de arredondamento na representação dos seguintes números decimais:

a)

$0.1$
b)

$10.1$
c)

$100.1$

  [0, 0, 1, 1, 1, 1, 0, 1,
  1, 1, 0, 0, 1, 1, 0, 0,
  1, 1, 0, 0, 1, 1, 0, 0,
  1, 1, 0, 0, 1, 1, 0, 1]

$|0.1-fl(0.1)|\approx 1.5e^{-9}$

[0, 1, 0, 0, 0, 0, 0, 1,
0, 0, 1, 0, 0, 0, 0, 1,
1, 0, 0, 1, 1, 0, 0, 1,
1, 0, 0, 1, 1, 0, 1, 0]

$|10.1-fl(10.1)|\approx 3.8e^{-7}$

[0, 1, 0, 0, 0, 0, 1, 0,
1, 1, 0, 0, 1, 0, 0, 0,
0, 0, 1, 1, 0, 0, 1, 1,
0, 0, 1, 1, 0, 0, 1, 1]

$|100.1-fl(100.1)|\approx 1.5e^{-6}$

Envie seu comentário

Aproveito para agradecer a todas/os que de forma assídua ou esporádica contribuem enviando correções, sugestões e críticas!

Este texto é disponibilizado nos termos da Licença Creative Commons Atribuição-CompartilhaIgual 4.0 Internacional. Ícones e elementos gráficos podem estar sujeitos a condições adicionais.

Política de uso de dados

Política de uso de dados

Matemática Numérica I

1.2 Representação de Números em Máquina

1.2.1 Números Inteiros

Exemplo 1.2.1.

Exemplo 1.2.2.

Observação 1.2.1.

1.2.2 Ponto Flutuante

Exemplo 1.2.3.

1.2.3 Erro de Arredondamento

Observação 1.2.2.

Observação 1.2.3.

1.2.4 Exercícios Resolvidos

ER 1.2.1.

Resolução.

ER 1.2.2.

Resolução.

ER 1.2.3.

Resolução.

1.2.5 Exercícios

E. 1.2.1.

E. 1.2.2.

E. 1.2.3.

E. 1.2.4.

E. 1.2.5.

Envie seu comentário

	$\displaystyle x=(-1)^{0}\cdot(1+2^{-23})\cdot 2^{127-127}$		(1.72)
	$\displaystyle x=1+2^{-23}$		(1.73)

	$\displaystyle\mathrm{eps}$	$\displaystyle=x-1$		(1.74)
		$\displaystyle=2^{-23}$		(1.75)