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

Edição das 19h19min de 19 de fevereiro de 2013 (ver código-fonte) Patonelli (disc | contribs) (→‎Representação de números fracionários e decimais numa base) ← Edição anterior		Edição das 19h33min de 1 de março de 2013 (ver código-fonte) Patonelli (disc | contribs) (→‎Uma função para colocar um número decimal na forma binária) Edição posterior →
Linha 75:		Linha 75:
	print (binario(21.75))		print (binario(21.75))
	</syntaxhighlight>}}		</syntaxhighlight>}}
		+
		+	==== Representação em ponto flutuante ====
		+	Consideramos uma base fixa <math>\beta > 1</math>. Um número real <math>\alpha \in \mathbb{R}</math> positivo pode ser escrito nesta base como:
		+	:<math>\alpha = [a_k\cdots a_0.b_1b_2\cdots]_{\beta} </math>
		+	Isto significa que:
		+	:<math>\alpha = a_k\beta^k + \cdots + a_0 + \frac{b_1}{\beta} +\frac{b_2}{\beta^2} + \cdots </math>
		+	Na equação acima, colocando <math> \beta^{k+1}</math> em evidência temos:
		+	:<math>\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} </math>
		+	ou ainda, lembrando da notação de um número numa base dada:
		+	:<math>\alpha = [0.a_k \cdots a_0 b_1 b_2\cdots]_{\beta} \times  \beta^{k+1} </math>
		+	Esta última fórmula é importante. O número real <math> \alpha</math> fica caracterizado por três dados:
		+	* O número <math> m = [0.a_k \cdots a_0 b_1 b_2\cdots]_{\beta} \in (0,1)</math> chamado de '''mantissa'''.
		+	* O número <math> e = k+1 </math> chamado de '''expoente'''
		+	* O sinal do número <math>\sigma</math>
		+	Esta representação do número <math>\alpha </math> como <math>\sigma m \times \beta^e</math> chamaremos de '''representação normal em ponto flutuante''' na base <math>\beta</math>.
		+	Em geral a base fica clara pelo contexto!

---

Edição das 19h33min de 1 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

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!