Processing math: 100%

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

De Stoa
Ir para: navegação, pesquisa
(Representação de números fracionários e decimais numa base)
(Uma função para colocar um número decimal na forma binária)
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

Cobra4.png

| Comunidade no Stoa | Disciplina no Moodle|

Conteúdo

 [ocultar

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 β>1 um número natural. Então podemos representar qualquer número inteiro k como a soma k=sgn(k)a0β0++asβs onde cada algarismo aj representa um número natural entre 0 e β1. Só as é diferente de zero. Esta representação é única. A representação de k na base β é k=±[asa0]β Deixando o sinal de k de fora, para simplificar. Podemos calcular os algarismos do número daddo na base β aplicando repetidas vezes o algoritmo da divisão. Escrevendo k=a0+β(a1+β(a2++βas))) vemos que a0 é o resto da divisão k//β, a1 é o resto da divisão (ka0)//β e assim por diante.

Exemplo: 39=[100111]2

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

Seja novamente β>1 um número natural.

Se x(0,1) então x=b1β++bkβk+ Diremos que x=[0.b1b2]β é a representação fracionária na base β 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 β>1. Um número real αR positivo pode ser escrito nesta base como: α=[aka0.b1b2]β Isto significa que: α=akβk++a0+b1β+b2β2+ Na equação acima, colocando βk+1 em evidência temos: α=(akβ++a0βk+1+b1βk+2+b2βk+3+)×βk+1 ou ainda, lembrando da notação de um número numa base dada: α=[0.aka0b1b2]β×βk+1 Esta última fórmula é importante. O número real α fica caracterizado por três dados:

  • O número m=[0.aka0b1b2]β(0,1) chamado de mantissa.
  • O número e=k+1 chamado de expoente
  • O sinal do número σ

Esta representação do número α como σm×βe chamaremos de representação normal em ponto flutuante na base β. Em geral a base fica clara pelo contexto!

Ferramentas pessoais
Espaços nominais

Variantes
Ações
Navegação
Imprimir/exportar
Ferramentas