Mudanças entre as edições de "Map0151"

Edição das 23h05min de 2 de março de 2013 (ver código-fonte) Patonelli (disc | contribs) (→‎Representação em ponto flutuante) ← Edição anterior		Edição das 12h57min de 6 de março de 2013 (ver código-fonte) Patonelli (disc | contribs) (→‎Números de máquina) Edição posterior →
Linha 100:		Linha 100:
	se o expoente de <math>\alpha</math> for maior que <math>M</math> não representamos o número. Senão tomamos sua mantissa e se o dígito <math>b_{d+1}\geq \beta/2</math> escolhemos		se o expoente de <math>\alpha</math> for maior que <math>M</math> não representamos o número. Senão tomamos sua mantissa e se o dígito <math>b_{d+1}\geq \beta/2</math> escolhemos
	o menor número de máquina maior que  <math>\alpha</math> para representá-lo. No caso de <math>b_{d+1} <\beta/2</math> o representante será o maior número de máquina menor que <math>\alpha</math>.		o menor número de máquina maior que  <math>\alpha</math> para representá-lo. No caso de <math>b_{d+1} <\beta/2</math> o representante será o maior número de máquina menor que <math>\alpha</math>.
		+
		+	Se denotarmos por <math> \underline{\alpha} </math> o truncamento do número <math>\alpha</math>, isto é, o maior número de máquina menor que <math>\alpha</math>. E
		+	por <math>\overline{\alpha}</math> o menor número de máquina maior que <math>\alpha</math>. Temos que:
		+	:<math>\overline{\alpha} - \underline{\alpha} = \beta^{e-D}</math>
		+	Com isto temos uma avaliação do erro absoluto e erro relativo do arredondamento:
		+	:<math>|\alpha -\operatorname{rd}(\alpha)| \leq \frac{\beta^{e-D}}{2}</math>
		+	:<math>\frac{|\alpha -\operatorname{rd}(\alpha)|}{|\alpha|}\leq \frac{\beta^{-D}}{2}</math>

---

Edição das 12h57min de 6 de março de 2013

Conteúdo  [ocultar]  1 Números no Computador 1.1 Representação de números inteiros numa base 1.2 Representação de números fracionários e decimais numa base 1.3 Uma função para colocar um número decimal na forma binária 1.4 Representação em ponto flutuante 1.5 Números de máquina

Números no Computador

Muitos dos algoritmos de cálculo numérico, por uma questão prática, deverão ser executados numa máquina real. Nestas máquinas, no entanto, a capacidade de memória para representação dos números é finita. Vários números reais (infinitos, de fato) terão a mesma representação no computador (ou calculadora), daí originando-se os erros de arredondamentos. Vamos ver qual é a técnica usada atualmente para diminuir os erros de arredondamentos.

Representação de números inteiros numa base

Seja $\beta > 1$ um número natural. Então podemos representar qualquer número inteiro $k$ como a soma

$$k= \text{sgn}(k)*a_0\beta^0 + \cdots + a_s \beta^s$$ onde cada algarismo $a_j$ representa um número natural entre $0$ e $\beta -1$. Só $a_s$ é diferente de zero. Esta representação é única. A representação de $k$ na base $\beta$ é $$k=\pm [a_s\dots a_0]_{\beta}$$ Deixando o sinal de $k$ de fora, para simplificar. Podemos calcular os algarismos do número daddo na base $\beta$ aplicando repetidas vezes o algoritmo da divisão. Escrevendo $$k = a_0 + \beta(a_1 +\beta( a_2 + \cdots +\beta a_s)\cdots ))$$ vemos que $a_0$ é o resto da divisão $k//\beta$, $a_1$ é o resto da divisão $(k-a_0)//\beta$ e assim por diante.

Exemplo: $39 = [100111]_2$

Representação de números fracionários e decimais numa base

Seja novamente $\beta > 1$ um número natural.

Se $x \in (0,1)$ então

$$x= \frac{b_1}{\beta} + \cdots + \frac{b_k}{\beta^k} + \cdots$$ Diremos que $x=[0.b_1 b_2\dots]_{\beta}$ é a representação fracionária na base $\beta$ de $x$. Quando não houver dúvidas de que base se trata, omite-se a base da notação!

Exemplo: $0.9= [0.1110011001100...]_2$

Uma função para colocar um número decimal na forma binária

In[1]:

# -*- coding: utf-8 -*- """ Spyder Editor """ def binario(a):     # da a representacao binaria do numero a     ParteInteira = int(a)     ParteDecimal = a-int(a)     # representacao binaria da parte inteira     # a lista seguinte guarda os dígitos da parte inteira     ListaDigitos=[]     while (ParteInteira > 0):         ListaDigitos.append(ParteInteira%2)         ParteInteira=ParteInteira//2     # lista dos digitos depois da virgula     ListaResto=[]     k=1     while ((ParteDecimal!=0)&(k<50)):         ListaResto.append(int(2*ParteDecimal))         ParteDecimal=2*ParteDecimal - int(2*ParteDecimal)         k=k+1     # produz a string de representacao:             i=len(ListaDigitos)-1     p1=""     while (i>=0):         p1=p1+str(ListaDigitos[i])         i=i-1     # Depois disso p1 tem a parte inteira     l=0     p2=""     while (l<len(ListaResto)):         p2=p2+str(ListaResto[l])         l=l+1         return p1+"."+p2     print (binario(21.75))

Representação em ponto flutuante

Consideramos uma base fixa $\beta > 1$. Um número real $\alpha \in \mathbb{R}$ positivo pode ser escrito nesta base como:

$$\alpha = [a_k\cdots a_0.b_1b_2\cdots]_{\beta}$$ Isto significa que: $$\alpha = a_k\beta^k + \cdots + a_0 + \frac{b_1}{\beta} +\frac{b_2}{\beta^2} + \cdots$$ Na equação acima, colocando $\beta^{k+1}$ em evidência temos: $$\alpha = \left( \frac{a_k}{\beta} + \cdots + \frac{a_0}{\beta^{k+1}} + \frac{b_1}{\beta^{k+2}} +\frac{b_2}{\beta^{k+3}} + \cdots\right)\times \beta^{k+1}$$ ou ainda, lembrando da notação de um número numa base dada: $$\alpha = [0.a_k \cdots a_0 b_1 b_2\cdots]_{\beta} \times \beta^{k+1}$$ Esta última fórmula é importante. O número real $\alpha$ fica caracterizado por três dados:

• O número $m = [0.a_k \cdots a_0 b_1 b_2\cdots]_{\beta} \in (0,1)$ chamado de mantissa.
• O número $e = k+1$ chamado de expoente
• O sinal do número $\sigma$

Esta representação do número $\alpha$ como $\sigma m \times \beta^e$ chamaremos de representação normal em ponto flutuante na base $\beta$. Em geral a base fica clara pelo contexto!

Números de máquina

Continuamos com a base fixa ($\beta$), mas na representação normal em ponto flutuante vamos admitir apenas números com a mantissa limitada a $D$ dígitos e o expoente limitado, em módulo, por um número inteiro $M$. O conjunto

$$\mathbf{M} = \left\{ [0.d_1\cdots d_D]_{\beta}\times \beta^e: |e| \leq M \right\}$$ é um conjunto de números de máquina definido pelos números $(\beta, D, M)$. Este é um conjunto finito com $(\beta-1)(\beta^{(D-1)})(2M+1)$ elementos. Vamos agora definir a função arredondamento, que é uma função sobrejetora $\operatorname{rd}: \mathbb{R} \to \mathbf{M}$. Seja $\alpha$ um número real; se o expoente de $\alpha$ for maior que $M$ não representamos o número. Senão tomamos sua mantissa e se o dígito $b_{d+1}\geq \beta/2$ escolhemos o menor número de máquina maior que $\alpha$ para representá-lo. No caso de $b_{d+1} <\beta/2$ o representante será o maior número de máquina menor que $\alpha$.

Se denotarmos por $\underline{\alpha}$ o truncamento do número $\alpha$, isto é, o maior número de máquina menor que $\alpha$. E por $\overline{\alpha}$ o menor número de máquina maior que $\alpha$. Temos que:

$$\overline{\alpha} - \underline{\alpha} = \beta^{e-D}$$ Com isto temos uma avaliação do erro absoluto e erro relativo do arredondamento: $$|\alpha -\operatorname{rd}(\alpha)| \leq \frac{\beta^{e-D}}{2}$$ $$\frac{|\alpha -\operatorname{rd}(\alpha)|}{|\alpha|}\leq \frac{\beta^{-D}}{2}$$