\documentclass[12pt]{article}
%\special{papersize=21.0cm,29.7cm} 
\usepackage[brazil]{babel}
\usepackage[latin1]{inputenc}
\usepackage[pdftex]{graphicx}

\special{papersize=8.5in,11in}
\setlength{\textheight}{22.5cm} 
\setlength{\textwidth}{16.5cm} 
\setlength{\topmargin}{-1.5 cm} 
\addtolength{\oddsidemargin}{-1.5cm} 
\addtolength{\evensidemargin}{-1.5cm} 

\begin{document}

\title{\bf Computador HIPO}
\author{}
\date{}
\maketitle

Para introduzirmos as no\c{c}\~{o}es b\'{a}sicas de como funciona um
computador, empregaremos um modelo imagin\'{a}rio (hipot\'{e}tico) que
denominaremos de  {\em computador hipo}. O funcionamento desse modelo
tem as caracter\'{\i}sticas b\'{a}sicas do funcionamento de um
computador real embora seja muito mais simples e did\'{a}tico.

\section{Introdu\c{c}\~{a}o}

Inicialmente vamos apresentar as unidades fundamentais de um computador:

 \begin{itemize}
 \item {\em Unidade Central de Processamento} ou CPU: \'{e} a unidade
que  controla o funcionamento do computador e executa as {\em
instru\c{c}\~{o}es}. Ela cont\'{e}m o {\em apontador de
instru\c{c}\~{o}es} e o {\em acumulador}, que  ser\~{a}o explicados
adiante.

 \item {\em Mem\'{o}ria Central}: \'{e} composta por unidades chamadas 
{\em posi\c{c}\~{o}es de mem\'{o}ria}. Nos computadores cada
posi\c{c}\~{a}o de  mem\'{o}ria \'{e} indicada por um {\em
endere\c{c}o}. No HIPO (daqui em diante  abreviaremos ``Computador
Hipo'' por Hipo) esse endere\c{c}o \'{e} um n\'{u}mero  de 00 a 99 (dois
algarismos).  Cada posi\c{c}\~{a}o de mem\'{o}ria pode conter um
n\'{u}mero. Esse n\'{u}mero \'{e}  representado por um sinal ( $+$ ou $-$ )
seguido de 4 algarismos decimais  (por exemplo, $+0002,  +1992, 
-1991$). Doravante denominaremos um sinal e 4 algarismos decimais de
{\em inteiro}.

 \item {\em Acumulador}: \'{e} uma mem\'{o}ria (chamada ``registrador'')
particular  da CPU. Como qualquer outra posicao de mem\'{o}ria, o
acumulador pode conter um {\em inteiro}. 
 \item {\em Instru\c{c}\~{a}o}: \'{e} uma ``opera\c{c}\~{a}o
b\'{a}sica'' que o computador \'{e} capaz de executar. Uma
instru\c{c}\~{a}o descreve uma a\c{c}\~{a}o a ser  executada pela CPU. 
Cada instru\c{c}\~{a}o \'{e} {\em codificada} de forma a ser 
representada por um {\em inteiro}. 

 \item {\em Apontador de Instru\c{c}\~{a}o}: \'{e} utilizado para
indicar \`{a} CPU  qual o endere\c{c}o da pr\'{o}xima instru\c{c}\~{a}o a
ser executada.

 \item {\em Teclado}: \'{e} a unidade que recebe dados do exterior do
computador  e os transmite \`{a} CPU.

 \item {\em Impressora}: como o nome diz, \'{e} a unidade que imprime
dados no  papel; esses dados s\~{a}o fornecidos pela CPU.

 \item {\em Programa}: \'{e} uma seq\"{u}\^{e}ncia de instru\c{c}\~{o}es
armazenada na  mem\'{o}ria.
 \end{itemize}


\section{Funcionamento do HIPO}

Para descrever o funcionamento do HIPO, vamos dar as regras b\'{a}sicas de 
funcionamento do componente principal, a CPU.  As regras s\~{a}o:
 \begin{enumerate}
 \item Ler a instru\c{c}\~{a}o que est\'{a} na posi\c{c}\~{a}o de
mem\'{o}ria indicada  pelo apontador de instru\c{c}\`{a}o.
 \item Mudar o apontador de instru\c{c}\~{a}o para a posi\c{c}\~{a}o de
mem\'{o}ria  seguinte.
 \item Interpretar e executar a instru\c{c}\~{a}o lida.
\end{enumerate}

Dadas as regras b\'{a}sicas, precisamos {\em carregar um programa} na
mem\'{o}ria e  fazer com que o apontador de instru\c{c}\~{o}es aponte
para a primeira instru\c{c}\~{a}o  do programa. Observa\c{c}\~{a}o: ``carregar''
um programa significa colocar cada  instru\c{c}\~{a}o do mesmo em uma
posi\c{c}\~{a}o de mem\'{o}ria. Feito isso, podemos acionar a CPU fazendo com
que ela siga as regras b\'{a}sicas e execute o programa dado.

{\bf Pergunta:} o que aconteceria se troc\'{a}ssemos as regras 2 e 3 de lugar?

\section{Codifica\c{c}\~{a}o de Instru\c{c}\~{o}es}
\label{tbla}

Infelizmente o HIPO n\~{a}o reconhece frases do tipo ``copie o
conte\'{u}do do  Acumulador para o Endere\c{c}o 30''. Por isso
precisamos escrever numa linguagem que este possa entender, i.e. em {\em
linguagem de m\'{a}quina}. Para este computador, uma instru\c{c}\~{a}o
ser\'{a} codificada por um {\em inteiro}. Por conven\c{c}\~{a}o todas as
instru\c{c}\~{o}es ser\~{a}o codificadas por  {\em inteiros} positivos
(i.e. com sinal $+$).

\subsection{Como fazer a codifica\c{c}\~{a}o das instru\c{c}\~{o}es}

Suponha que temos que passar para a ``linguagem do HIPO'' a instru\c{c}\~{a}o 
      ``Copie o conte\'{u}do do Acumulador para o Endere\c{c}o 30'':

Em primeiro lugar, utilizamos o sinal $+$. Os dois primeiros algarismos
correspondem \`{a} instru\c{c}\~{a}o, ou seja,  \`{a} opera\c{c}\~{a}o a
ser executada pela CPU.  Na sec\c{c}\~{a}o 4 listamos os  c\'{o}digos de
todas as instru\c{c}\~{o}es do HIPO. O c\'{o}digo da instru\c{c}\~{a}o 
``copie o conte\'{u}do do acumulador no  endere\c{c}o EE'' \'{e} o
n\'{u}mero 12. 

Os dois \'{u}ltimos algarismos do c\'{o}digo correspondem ao
endere\c{c}o de uma  posi\c{c}\~{a}o de mem\'{o}ria, que neste caso
\'{e} o 30. Logo a instru\c{c}\~{a}o acima \'{e} codificada, em
linguagem de m\'{a}quina, como 
 $$ +1230$$

Vamos a um outro exemplo: A instrucao \'{e} ``Se o conte\'{u}do do
Acumulador for menor que zero, desvie  para o endere\c{c}o 11''.
 \begin{itemize}
 \item  Sinal $+$ (por conven\c{c}\~{a}o)
 \item  Os dois primeiros algarismos correspondem a essa
instru\c{c}\~{a}o de desvio: 54 (confira na tabela)
 \item  Os dois \'{u}ltimos algarismos indicam o endere\c{c}o
referenciado: 11
 \end{itemize} 
 Portanto a codifica\c{c}\~{a}o desta instru\c{c}\~{a}o na linguagem
HIPO \'{e} $+5411$.

{\bf exerc\'{\i}cios}
 \begin{enumerate} 
 \item Quais s\~{a}o as vantagens a as desvantagens de se codificar as
instru\c{c}\~{o}es desta maneira.
 \item Qual \'{e} o n\'{u}mero m\'{a}ximo de instru\c{c}\~{o}es que
cabem na mem\'{o}ria do computador?
 \item \'{E} poss\'{\i}vel diferenciar uma instru\c{c}\~{a}o de um dado?
Por qu\^{e}?
 \end{enumerate}

%trocar por subsection%
\section{Instru\c{c}\~{o}es do computador hipo}

Cada instru\c{c}\~{a}o \'{e} composta de um c\'{o}digo mais um endere\c{c}o
relativo a esse c\'{o}digo, da seguinte maneira: \ \ {\bf  +IIEE} \ \ 
Onde {\bf II} \'{e} o c\'{o}digo de uma das instru\c{c}\~{o}es abaixo, e
{\bf EE} \'{e} o endere\c{c}o ao qual ela se refere $(00 \leq EE \leq
99)$. A seguir, [EE]  indica o conte\'{u}do de EE, [AC]  indica o
conte\'{u}do do  acumulador, AI indica o apontador de instrucao e (XXX)
indica o c\'{o}digo  simb\'{o}lico abreviado.

 \begin{description}
 \item[11:] (CEA) Copie o conte\'{u}do do endere\c{c}o EE no acumulador.
 (AC recebe [EE]). 
 \item[12:] (CAE)   Copie o conte\'{u}do do acumulador no endere\c{c}o EE.
 (EE recebe [AC])
 \item[21:] (SOM)   Some o conte\'{u}do do endere\c{c}o EE com o
conte\'{u}do do  acumulador e guarde o resultado no acumulador. 
 (AC recebe [AC] + [EE])
 \item[22:] (SUB)  Subtraia o conte\'{u}do do endere\c{c}o EE do
conte\'{u}do do  acumulador e guarde o resultado no acumulador.  
 (AC recebe [AC] - [EE]) 
 \item[23:] (MUL)   Multiplique o conte\'{u}do do endere\c{c}o EE com o 
conte\'{u}do do acumulador e guarde o resultado no acumulador.
 (AC recebe [AC] * [EE]) 
 \item[24:] (DIV)  Divide o conte\'{u}do do acumulador pelo conte\'{u}do
do  endere\c{c}o EE e guarde o resultado no acumulador.
 (AC recebe [AC] / [EE])	     
 \item[25:] (MOD) [AC] recebe o resto da divis\~{a}o [AC] / [EE]. 
 \item[31:] (LER)   Leia um n\'{u}mero e guarde-o no endere\c{c}o EE.
 (EE recebe o valor lido)
 \item[41:] (IMP)   Imprima o conte\'{u}do do endere\c{c}o EE.
 \item[50:] (NOP)   Nenhuma opera\c{c}\~{a}o \'{e} efetuada.
 \item[51:] (DES)   Desvie a execu\c{c}\~{a}o para o endere\c{c}o EE,
 i.e. AI recebe EE.
 \item[52:] (DPO) Se o conte\'{u}do do acumulador for maior do que 
zero, desvie a execu\c{c}\~{a}o para  o endere\c{c}o EE.
 (Se [AC] $>$ 0, AI recebe  EE).
 \item[53:] (DPZ) Se o conte\'{u}do do acumulador for maior ou igual a
zero, desvie a execu\c{c}\~{a}o para o endere\c{c}o EE.
 (Se [AC] $\geq$ 0, AI recebe  EE).
 \item[54:] (DNE)   Se o conte\'{u}do do acumulador for menor do que
zero,  desvie a execu\c{c}\~{a}o para o endere\c{c}o EE.
 (Se [AC] $<$ 0, AI recebe  EE.)
 \item[55:] (DNZ) Se o conte\'{u}do do acumulador for menor ou igual a
zero, desvie a execu\c{c}\~{a}o para o endere\c{c}o EE.
 (Se [AC] $\leq$ 0, AI recebe  EE).
 \item[56:] (DDZ)   Se o conte\'{u}do do acumulador for diferente de
zero,  desvie a execu\c{c}\~{a}o para o endere\c{c}o EE.
 (Se [AC] $\neq$ 0, AI recebe  EE).
 \item[57:] (DZZ)   Se o conte\'{u}do do acumulador for igual a zero,
desvie a  execu\c{c}\~{a}o para o endere\c{c}o EE.
 (Se [AC] $=$ 0, AI recebe  EE).	     
 \item[58:] (DDF)  Se o conteudo do acumulador for diferente de
infinito,  desvie a execu\c{c}\~{a}o para o endere\c{c}o EE.
 (Se [AC] $\neq$ INF, AI recebe  EE).
 \item[59:] (DFF) Se o conteudo do acumulador for infinito, desvie a 
execu\c{c}\~{a}o para o endere\c{c}o EE. 
 (Se [AC] $=$ INF, AI recebe EE).
 \item[61:] (ADE) Desloque os digitos do acumulador uma posi\c{c}\~{a}o
\`{a}  esquerda, desprezando o digito mais significativo. 
 \item[62:] (ADD) Desloque os digitos do acumulador uma posi\c{c}\~{a}o
\`{a}  direita, desprezando o digito menos significativo. 
 \item[70:] (PAR)  Pare a execu\c{c}\~{a}o do programa. OBS.: Esta
instru\c{c}\~{a}o deve ser executada para encerrar a execu\c{c}\~{a}o do
programa.
 \end{description}

\newpage
\section{PROBLEMA 1}

Dada uma seq\"{u}\^{e}ncia de n\'{u}meros inteiros n\~{a}o negativos,
imprimir a sua soma. A seq\"{u}\^{e}ncia \'{e} seguida de um n\'{u}mero
negativo. Exemplo de sequ\^{e}ncia de entrada: +0100, + 0015, +0000,
+0007, -0002.

Programa 1:

{\small
\begin{table}[h]
\begin{center}
\begin{tabular}{|c|c|c|c|}
\hline
{} & {} & Linguagem & Linguagem\\
Instru\c{c}\~{o}es por extenso & Endere\c{c}o & de m\'{a}quina & 
simb\'{o}lica \\
{} & {} & do hipo & (de montagem)\\
\hline
\hline
Copie o conte\'{u}do do endere\c{c}o &  01 & $+$1130 & CEA zero\\
30 no acumulador & & & \\
\hline
Copie o conte\'{u}do do acumulador no & 02 & $+$1240 & CAE soma\\
endere\c{c}o 40 & & &\\
\hline
Leia um n\'{u}mero e coloque no & 03 & $+$3150 & {\bf leia:} LER  num\\
endere\c{c}o 50 & & &\\
\hline
Imprima o conte\'{u}do do endere\c{c}o 50 & 04 & $+$4150 & IMP num\\
\hline
Copie o conte\'{u}do do endere\c{c}o 50 & 05 & $+$1150 & CEA num\\
no acumulador & & &\\
\hline
Se o conte\'{u}do do acumulador for & & &\\
menor que zero, desvie para o & 06 & $+$5411 & DNE fim\\
endere\c{c}o 11 & & &\\
\hline
Copie o conte\'{u}do do endere\c{c}o 40 & 07 & $+$1140 & CEA soma\\
no acumulador & & &\\
\hline
Some o conte\'{u}do do endere\c{c}o 50 & & &\\
com o conte\'{u}do do acumulador e & 08 & $+$2150 & SOM num\\
guarde no acumulador & & &\\
\hline
Copie o conte\'{u}do do acumulador no & 09 & $+$1240 & CAE soma\\
endere\c{c}o 40 & & &\\
\hline
Desvie para o endere\c{c}o 03 & 10 & $+$5103 & DES leia\\
\hline
Imprima o conte\'{u}do do endere\c{c}o 40 & 11 & $+$4140 & {\bf fim:} 
IMP soma\\
\hline
Pare & 12 & $+$7000 & PAR\\
\hline
& 30 & +0000 & {\bf zero:}\\
\hline
& 40 & & {\bf soma:}\\
\hline
& 50 & & {\bf num:}\\
\hline 
\end{tabular}
\end{center}
\end{table}
}

A quarta coluna da tabela acima representa o programa escrito em uma 
{\em linguagem de montagem} ou {\em assemby}. Escrever um programa em
{\em assembly} \'{e} bem mais f\'{a}cil que escrev\^{e}-lo diretamente em
linguagem de m\'{a}quina. Poder\'{\i}amos inclusive escrever um {\em programa
montador}, ou {\em assembler}, que se encarregue de traduzir {\em
assembly}, para linguagem de m\'{a}quina (i.e. um programa que gere o
conte\'{u}do da terceira coluna a partir do conte\'{u}do da segunda e da quarta
colunas). 


\section{Fluxograma}

Damos a seguir uma outra representa\c{c}\~{a}o simb\'{o}lica do programa 1,
a de diagrama de blocos, ou fluxograma. Seu significado deve ser
evidente.

\begin{table}[h]
\begin{center}
\begin{tabular}{c c c c c c }
End. & R\'{o}tulo & Assembly &  & Fluxograma & \\

\\
    & &          &  & In\'{\i}cio        & \\  
    & &          &  & $\downarrow$       & \\  
01  & &  CEA zero &  & Soma $\Leftarrow$ 0 & \\
02  & &  CAE soma &  & $\downarrow$ & \\
03  & {\bf leia} &  LER num & & Ler num & $\leftarrow$  \\
    & & & &  $\downarrow$ &  \\ 
04  & & IMP num & & Imprimir [num] &  \\
    & & & & $\downarrow$  & $\uparrow$ \\
05  & &  CEA num & & \\
06  & &  DNE fim  & $\leftarrow$ & Se [num] $<$ 0 & \\
    & &           &  \mbox{sim}  &                & \\ 
07  & &  CEA soma & $\downarrow$ & \mbox{\ \ \ } $\downarrow$ \mbox{n\~{a}o} & \\
08  & &  SOM num  &  & & \\
09  & & CAE soma & & soma $\Leftarrow$ [soma]+[num] &  \\
    & & &  $\downarrow$ & & $\uparrow$ \\ 
10  & &  DES leia &  &  $\hookrightarrow$ & \\
    & & &    & \\ 
11  & {\bf fim} & IMP soma & $\rightarrow$ & Imprimir [soma] & \\
    & & & &  $\downarrow$ & \\ 
12  & &  PAR & & Fim & \\
\\ 
30  & {\bf zero}& &\\
40  & {\bf soma}& &\\
50  & {\bf num}& &\\
\end{tabular}
\end{center}
\end{table}

\section{Representa\c{c}\~{o}es Internas}

\subsection{Letras}

Apesar dos computadores s\'{o} lidarem com n\'{u}meros, eles podem armazenar
informa\c{c}\~{o}es que, a princ\'{\i}pio, n\~{a}o s\~{a}o n\'{u}meros. Por exemplo, como
representar\'{\i}amos a letra ``A'' no computador ?  Como guardar\'{\i}amos um
nome (por ex.  ``CARLOS DA SILVA'')? Podemos representar objetos como
n\'{u}meros, desde que tenhamos uma tabela de tradu\c{c}\~{a}o que diga qual n\'{u}mero
\'{e} associado a qual objeto. Vamos ver como representar caracteres na
mem\'{o}ria do computador : instalamos no computador uma tabela assim :
 A = +0001, B = +0002,..., Z = +0026, 
 0 = +0027, 1 = +0028, ... , 9 = +0036, 
 a = +0037, b = +0038, ... 
Da\'{\i}, podemos ``traduzir'' qualquer caractere para um n\'{u}mero e coloc\'{a}-lo na
mem\'{o}ria do computador.

Como faremos para representar seq\"{u}\^{e}ncias de caracteres? A maneira mais simples
\'{e} colocar cada letra em uma posi\c{c}\~{a}o da mem\'{o}ria em seq\"{u}\^{e}ncia, por exemplo :
``CARLOS'' ficaria assim :\\
C,A,R,L,O,S =    +0003, +0001, +0018, +0012, +0015, +0019

\subsection{Overflow}

Vamos agora discutir alguns detalhes adicionais sobre a 
representa\c{c}\~{a}o de n\'{u}meros inteiros.

Em primeiro lugar notemos que h\'{a} duas maneiras poss\'{\i}veis de representar
o n\'{u}mero zero, a saber: +0000 e -0000. Por conven\c{c}\~{a}o, fica
estabelecido que zero \'{e} representado por +0000.

Em segundo lugar falta estabelecer o resultado de uma opera\c{c}\~{a}o 
aritm\'{e}tica entre dois {\em inteiros} cujo resultado n\~{a}o pode ser
expresso como um {\em inteiro}. Por exemplo se somarmos +9991 e +0010, o
``resultado'' (10001) n\~{a}o \'{e} mais represent\'{a}vel como um {\em
inteiro} (pois {\em inteiros} sendo constitu\'{\i}dos de um sinal e 4
algarismos decimais s\'{o} podem representar n\'{u}meros inteiros entre
-9999 e +9999). Casos deste tipo s\~{a}o chamados de {\em overflow}
(transbordamento). Neste caso convencionamos que a CPU retorna o c\'{o}digo
-0000, que fica  sendo nossa representa\c{c}\~{a}o de infinito (INF), ou
de qualquer n\'{u}mero  inteiro menor que -9999 ou maior que +9999.  Tamb\'{e}m
por conven\c{c}\~{a}o, o resultado de qualquer opera\c{c}\~{a}o aritm\'{e}tica
envolvendo INF tem como resultado INF; e para as opera\c{c}\~{o}es de
desvio, INF (-0000) n\~{a}o \'{e} igual, nem maior, nem menor que zero
(+0000).

{\bf exemplos:} 
\begin{center}
(-9920 - 80) + 5000 = INF + 5000 = INF.\\
(-9920 + 5000) - 80 = -4920 - 80 = -5000.
\end{center}

\subsection{HIPO-II} 

Ao multiplicarmos dois inteiros de 4 digitos (n\~{a}o nulos), teremos
sempre overflow! Isto motiva um modelo melhorado do HIPO, o HIPO-II. 
No HIPO-II o acumulador tem  ``precis\~{a}o dupla'', i.e. o acumumulador
pode conter um n\'{u}mero  representado por um sinal ( $+$ ou $-$ )
seguidos de 8 algarismos decimais   ( por exemplo, $+00000002, 
+12345678, -12345678$).  Doravante denominaremos um sinal e 8 algarismos
decimais de {\em inteiro longo}. Repare que qualquer produto de 2 
inteiros pode ser representado como um inteiro longo. 

Ao Copiarmos o conte\'{u}do do endere\c{c}o EE no acumulador 
(instru\c{c}\~{a}o CEA), o sinal e os 4 digitos menos significativos
(\`{a} direita) de AC  recebem [EE]. Assim o inteiro $+1998$ ser\'{a} 
copiado para o acumulador como o inteiro longo $+00001998$. 

Ao Copiarmos o conte\'{u}do do acumulador no endere\c{c}o EE  
(instru\c{c}\~{a}o CAE), [EE] recebe o sinal e os 4 digitos menos
significativos (\`{a} direita) de AC. Assim o inteiro logo 
$+12345678$ em AC ser\'{a} copiado para a posi\c{c}\~{a}o de 
mem\'{o}ria EE como o inteiro $+5678$ . 


\subsection{Ponto Flutuante}

O HIPO s\'{o} guarda n\'{u}meros inteiros na mem\'{o}ria, o que far\'{\i}amos para
guardar n\'{u}meros fracion\'{a}rios? Lembrem-se que um n\'{u}mero no padr\~{a}o HIPO,
um {\em inteiro}, \'{e} um sinal seguido de quatro algarismos decimais,
como  +1234,  -3141, ou generalizando, $\pm$DDDD

Agora, nada nos impede de imaginar um ponto no meio deste n\'{u}mero, por
exemplo assim: $\pm$DD.DD Isso corresponderia a olharmos +1234 na
mem\'{o}ria como o n\'{u}mero 12.34. Assim podemos representar n\'{u}meros de -99.99
at\'{e} +99.99 na mem\'{o}ria do  HIPO. Nada nos impede de imaginar este ponto
em posi\c{c}\~{o}es diferentes: $\pm$DDD.D ou $\pm$D.DDD , etc. Este m\'{e}todo s\'{o} \'{e}
bom quando os n\'{u}meros t\^{e}m o mesmo ``tamanho'', ou seja, est\~{a}o mais ou
menos pr\'{o}ximos. Por\'{e}m, n\~{a}o poder\'{\i}amos fazer a conta \  $1000 \times 2.2
= 2200$ usando a representa\c{c}\~{a}o de ponto fixo no HIPO (pois o ponto
precisaria estar num lugar diferente em cada n\'{u}mero). Esta conta seria
poss\'{\i}vel se tiv\'{e}ssemos um ponto m\'{o}vel (``ponto flutuante'' em g\'{\i}ria de
computa\c{c}\~{a}o).

Uma maneira (existem v\'{a}rias outras) de representar um n\'{u}mero com ponto
flutuante no HIPO \'{e} colocar em uma posi\c{c}\~{a}o de mem\'{o}ria a mantissa (os
 algarismos do n\'{u}mero), e noutra colocar o expoente (a posi\c{c}\~{a}o
do ponto).  Um n\'{u}mero com ponto flutuante no formato HIPO ser\'{a} doravante
denominado {\em flutuante}.

Para colocar um n\'{u}mero no formato {\em flutuante} primeiro o escrevemos
em  nota\c{c}\~{a}o cient\'{\i}fica: \ \ $230 = 2.30 \times 10^2 = 2.3E+2$. \ \ 
Depois codificamos o n\'{u}mero no formato: \ \  $\pm$MMMM $\pm$EEEE \ \ 
onde $\pm$MMMM \'{e} a mantissa; no nosso exemplo: \ \ +2300 \ \  ; e
$\pm$EEEE \'{e} o expoente, no nosso exemplo: +0002.

Note que imaginamos um ponto fixo após o primeiro d\'{\i}gito da  mantissa, d\'{\i}gito
este sempre diferente de zero ($\pm$M.MMM). \ 
Outro exemplo: \ \ $0.00000032 = 3.2E-7$. \ \ 
aqui a mantissa \'{e} +3200 e o expoente \'{e} -0007.


Este truque de colocarmos um n\'{u}mero em duas posi\c{c}\~{o}es de mem\'{o}ria \'{e}
bastante comum (normalmente os n\'{u}meros s\~{a}o colocados em v\'{a}rias posi\c{c}\~{o}es
de mem\'{o}ria) e n\~{a}o \'{e} muito dif\'{\i}cil programarmos o computador para fazer
contas corretamente com {\em flutuantes}. No entanto, este m\'{e}todo de
representar n\'{u}meros tem limita\c{c}\~{o}es : 12345 n\~{a}o pode ser representado
exatamente, nem $\frac{1}{3} = 0.333\ldots$,
 $\sqrt{2} = 1.414213562\ldots$ ou $\pi =  3.14159265\ldots$.
 
Uma opera\c{c}\~{a}o aritim\'{e}tica (+,-,$*$,/) entre dois {\em flutuantes}
\'{e} denominada um FLOP. O numero de FLOPs que um computador consegue
realizar  por segundo \'{e} uma das medidas mais importantes de seu
desempenho.  Para aumentar seu desempenho o computador tem muitas vezes
uma unidade de  processamento auxiliar, sob comando da CPU,
especializada em FLOPs: \'{e} a FPU.  Como curiosidade, compare a
FLOPagem (FLOPs/segundo) de alguns computadores no mercado:

\begin{table}[h]
\begin{center}
\begin{tabular}{|c|c|c|c|}
\hline
Computador & CPU & FPU & FLOPagem \\
\hline \hline
PC-XT & Intel 8086 & sem FPU & $1E3$ \\
\hline
PC-XT & Intel 8086 & Intel 8087 & $50E3$ \\
\hline
PC-AT & \multicolumn{2}{|c|}{Intel i486 com FPU incorporada}  & $5E6$ \\
\hline
PC-AT & \multicolumn{2}{|c|}{Placa com coprocessador i860} & $50E6$\\
\hline
CRAY-1 & \multicolumn{2}{|c|}{propriet\'{a}ria} & $50E6$\\
\hline
CRAY-XMP & \multicolumn{2}{|c|}{propriet\'{a}ria} & $200E6$\\
\hline
Touchstone Delta & \multicolumn{2}{|c|}{528 CPUs i860} & $10E9$ \\
\hline
\end{tabular}
\end{center}
\end{table}

Estas medidas de desempenho s\~{a}o freq\"{u}entemente dadas em *FLOPs,  
onde * indica a inicial de: 
Kilo = $10^3$, Mega = $10^6$, Giga = $10^9$ ou Tera = $10^{12}$. 

\vspace{1cm}
\noindent
{\bf exerc\'{\i}cios}
\begin{enumerate}
\item Traduza para o formato num\'{e}rico do computador HIPO:
{\bf a)} ``A'', ``Abacaxi''; \ \ 
{\bf b)} $0.123$, \ $23.22$, $1,66*10^{-24}$.  
\item Fa\c{c}a um programa no HIPO-II para somar dois {\em flutuantes}.
\item Fa\c{c}a um programa no HIPO-II para multiplicar dois {\em flutuantes}. 
\end{enumerate}
 

\section{Bases de Numera\c{c}\~{a}o}
 
Considere os seguintes n\'{u}meros: $19$ \/ e $91$. Embora os dois
n\'{u}meros contenham os mesmos d\'{\i}gitos (1 e 9) sabemos que eles
s\~{a}o diferentes e, al\'{e}m disso, que o segundo n\'{u}mero \'{e}
maior que o primeiro (pois eles t\^{e}m o mesmo n\'{u}mero de
d\'{\i}gitos e o d\'{\i}gito  mais \`{a} esquerda de 91 \'{e} maior que
o d\'{\i}gito mais \`{a} esquerda de 19).
 
O sistema decimal  \'{e} um sistema de numera\c{c}\~{a}o que usa a {\em
base de numera\c{c}\~{a}o 10 }, como o pr\'{o}prio nome indica. Cada
nu\'{m}ero \'{e} escrito usando-se {\em os d\'{\i}gitos 0, 1, 2, 3, 4, 5
, 6, 7, 8 e 9} e a cada algarismo deste n\'{u}mero corresponde um valor
num\'{e}rico que depende da posi\c{c}\~{a}o desse algarismo no
n\'{u}mero. Assim, por exemplo, o n\'{u}mero 1992 \'{e} uma
nota\c{c}\~{a}o abreviada do seguinte:
 $$1992=1000+900+90+2=1*1000+9*100+9*10+2=1*10^{3}+9*10^{2}+9*10^{1}+2*10^{0}$$
 
 
Formalizando este conceito de base de numera\c{c}\~{a}o, em uma base
qualquer B  (no caso decimal, $B = 10$), um n\'{u}mero N \'{e}
representado explicitando-se a  base por
 $$ N = (d_{m} d_{m-1} ... d_{1} d_{0})_{B}$$ onde $d_{m}$,..., $d_{1}$
e $d_{0}$ s\~{a}o seus d\'{\i}gitos, representados pelos algarismos
$0$\/ a $B-1$.  O valor de N \'{e} dado por 
 $$ N = d_{m}*B^{m} + d_{m-1}*B^{m-1} + ... + d_{1}*B^{1} + d_{0}*B^{0} $$

Os computadores s\~{a}o constru\'{\i}dos utilizando-se, por causa de
fatores  tecnol\'{o}gicos, um sistema {\em bin\'{a}rio} de
representa\c{c}\~{a}o interna de  n\'{u}meros e de caracteres. Assim,
cada d\'{\i}gito de uma ``palavra'' pode  conter apenas os algarismos
$0$\/ e $1$.  Neste sistema de numera\c{c}\~{a}o que usa apenas dois
algarismos, estes s\~{a}o  chamados de {\em bit} ( do Ingl\^{e}s,
``binary digit'' ). No entanto, a grande maioria dos computadores usa um
agrupamento de 8 bits como unidade de informa\c{c}\~{a}o, i.e. cada
posi\c{c}\~{a}o de mem\'{o}ria contem 8 {\em bits}. Esses agrupamentos
de 8 bits s\~{a}o chamados de {\em Byte}, e podem representar  at\'{e}
$2^{8}=256$ n\'{u}meros ou caracteres.
 
{\bf Observa\c{c}\~{a}o :} No caso do HIPO, convencionamos utilizar o
sistema decimal para manter a simplicidade do modelo.
 
Exemplo: $(1101)_{2}$ \'{e} um n\'{u}mero cujo valor \'{e}
 $$ (1101) = 1*2^{3} + 1*2^{2} + 0*2^{1} + 1*2^{0} = 8 + 4 + 0 + 1 = 13 $$
 
Outras bases de numera\c{c}\~{a}o bastante utilizadas em computa\c{c}\~{a}o s\~{a}o:
\begin{itemize}
 \item {\em octal}, ou base 8, que usa os d\'{\i}gitos
 $  0, 1, 2, 3, 4, 5, 6, 7 $.
 \item {\em hexadecimal}, ou base 16, que usa os d\'{\i}gitos
 $  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, f$ 
onde os algarismos $a$\ldots$f$ valem, respectivamente, 
$10$\ldots$15$.
\end{itemize}
 
\vspace{1cm}
\noindent
{\bf  exerc\'{\i}cios}
 \begin{enumerate}
 \item Converter para a base decimal os seguintes n\'{u}meros bin\'{a}rios:
 $1111$, $10101$, $00101$.
 \item Represente em base bin\'{a}ria os seguintes n\'{u}meros decimais:
 $8$, $16$, $15$, $20$.
 \item Deduza uma regra de convers\~{a}o de n\'{u}meros decimais para
n\'{u}meros  bin\'{a}rios. Sugest\~{a}o: divida sucessivamente o
n\'{u}mero decimal por 2 e veja  o resto de cada divis\~{a}o.
 \item Usando a regra deduzida no exerc\'{\i}cio anterior, converta para
a base bin\'{a}ria os seguintes n\'{u}meros decimais: $20$, $21$, $73$,
$512$, $1984$. Verifique o resultado convertendo os n\'{u}meros
bin\'{a}rios para a base 10,  empregando a f\'{o}rmula de pot\^{e}ncia
j\'{a} vista.
 \item Converta para a base 10 os seguintes n\'{u}meros: $(2101)_{3}$,
 $(1765)_{8}$, $(1a2f)_{16}$
\end{enumerate}


\section*{Bibliografia}

A id\'{e}ia de definir um modelo did\'{a}tico de computador (como o HIPO) \'{e} bastante 
antiga e difundida. O exemplo mais famoso desta pr\'{a}tica \'{e} o computador MIX 
apresentado em [Knuth69].
A presente apostila cont\'{e}m, com pequenas altera\c{c}\~{o}es, material de 
[Setzer84] e [Setzer91].

\begin{description}
\item{[Knuth69]}. D.E.Knuth,{\em The Art of Computer Programming Vol.1},
Addison-Wesley Publishing Company, Readind.
\item{[Setzer84]}. W.W.Setzer e  R.Terada, {\em
Introdu\c{c}\~{a}o \`{a} Computa\c{c}\~{a}o e \`{a} Constru\c{c}\~{a}o de Algor\'{\i}tmos}. IME-USP, S\~{a}o Paulo.  
\item{[Setzer90]} W.W.Setzer, {\em Apostila do Dia da Computa\c{c}\~{a}o}.
                  IME-USP, S\~{a}o Paulo.
\end{description}

\end{document}
