Вы находитесь на странице: 1из 220

Introduo Organizao e

Programao de Computadores
usando Logisim e Scilab

Osvaldo Carvalho
Departamento de Cincia da Computao
UFMG
osvaldo@dcc.ufmg.br

2 Semestre de 2010

IOPC 2010_2-3

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Contedo
1

Introduo ............................................................................................................................. 1
1.1

Computadores ............................................................................................................... 1

1.2

Informao Analgica e Informao Digital .................................................................. 4

1.3

Computadores e Informao ........................................................................................ 7

1.4

Converses anlogo-digital e digital-analgica ............................................................. 8

1.5

Sensores e atuadores .................................................................................................. 12

1.6

Memrias .................................................................................................................... 15

1.7

Organizao do Texto .................................................................................................. 17

1.7.1

Organizao de Computadores ........................................................................... 17

1.7.2

Linguagem e Ambiente Scilab ............................................................................. 18

1.7.3

Algoritmos e Programas ...................................................................................... 21

Organizao de Computadores ........................................................................................... 23


2.1

Bits e cdigos............................................................................................................... 23

2.2

Circuitos Combinatrios .............................................................................................. 26

2.2.1

lgebra de Boole ................................................................................................. 27

2.2.2

Portas Lgicas ...................................................................................................... 27

2.2.3

Introduo ao Logisim ......................................................................................... 31

2.2.4

Aritmtica com operaes lgicas ...................................................................... 36

2.2.5

Sntese de Circuitos Combinatrios .................................................................... 42

2.2.6

Comparao de binrios sem sinal...................................................................... 48

2.2.7

Multiplexadores e Demultiplexadores ................................................................ 51

2.3

Circuitos Sequenciais................................................................................................... 54

2.3.1

Flip-flops e Registradores .................................................................................... 54

2.3.2

Barramentos e Controle de Fluxo de Dados ....................................................... 57

2.3.3

Memrias ............................................................................................................ 58

2.3.4

Acumuladores ..................................................................................................... 60

2.3.5

Uma CPU no Automtica ................................................................................... 61

2.3.6

Osciladores ou Clocks .......................................................................................... 63

2.4

Organizao de uma CPU ............................................................................................ 64

2.4.1

Ciclo de Instruo ................................................................................................ 66

2.4.2

Instrues ............................................................................................................ 68

2.4.3

Programao em Assembler ............................................................................... 70

2.4.4

Montagem do Programa Executvel ................................................................... 72

2.4.5

O Circuito Principal da CPU Pipoca...................................................................... 73

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

ii

2.4.6

O Contador de Programa .................................................................................... 77

2.4.7

A Unidade de Controle ........................................................................................ 77

2.4.8

O Ciclo de Micro-Instruo .................................................................................. 81

2.4.9

O Micro-Programa ............................................................................................... 86

2.4.10

A Planilha Pipoca.xls ............................................................................................ 89

Ambiente e Linguagem Scilab ............................................................................................. 95


3.1

3.1.1

Variveis e Comandos de Atribuio................................................................... 98

3.1.2

Programas Scilab ............................................................................................... 101

3.1.3

Loops: os comandos for e while .................................................................. 107

3.1.4

Valores Lgicos e Strings ................................................................................... 112

3.1.5

Comandos Aninhados........................................................................................ 116

3.1.6

Arquivos............................................................................................................. 119

3.2

Matrizes..................................................................................................................... 124

3.2.1

Atribuindo valores a uma matriz ....................................................................... 124

3.2.2

Vetores linha e coluna ....................................................................................... 126

3.2.3

Referenciando partes de uma matriz ................................................................ 126

3.2.4

Aritmtica matricial ........................................................................................... 127

3.2.5

Construindo matrizes ........................................................................................ 131

3.2.6

Matrizes e Grficos............................................................................................ 133

3.2.7

Matrizes de Strings e Arquivos .......................................................................... 135

3.2.8

Matrizes Numricas e Arquivos ........................................................................ 136

3.2.9

Matrizes e expresses lgicas ........................................................................... 138

3.3

Introduo ao Ambiente e Linguagem Scilab ........................................................... 95

Funes ..................................................................................................................... 139

3.3.1

Sintaxe ............................................................................................................... 141

3.3.2

Funes, arquivos fonte e o Scilab .................................................................... 142

3.3.3

Funes, Matrizes, Loops e Induo ................................................................. 144

3.3.4

Recursividade .................................................................................................... 149

3.3.5

Funes e Desenvolvimento Top-down ............................................................ 151

3.3.6

Desenhando Mapas........................................................................................... 153

Algoritmos ......................................................................................................................... 157


4.1

Definio e Caractersticas ........................................................................................ 157

4.1.1

Especificao ..................................................................................................... 157

4.1.2

Correo ............................................................................................................ 157

4.1.3

Eficincia e Complexidade Computacional ....................................................... 158

4.2

Pesquisa..................................................................................................................... 164

4.2.1

Pesquisa Seqencial .......................................................................................... 165

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

iii
4.2.2
4.3

Pesquisa Binria ................................................................................................ 166

Ordenao ................................................................................................................. 168

4.3.1

Seleo e Troca.................................................................................................. 168

4.3.2

Intercalao (MergeSort) .................................................................................. 173

4.3.3

Partio (QuickSort) .......................................................................................... 177

4.3.4

Dividir para Conquistar...................................................................................... 179

4.4

Algoritmos Numricos............................................................................................... 179

4.4.1

Integrao por Trapzios................................................................................... 180

4.4.2

Bisseo ............................................................................................................. 183

4.4.3

Srie de Taylor para exp(x) e Cancelamento Catastrfico ................................ 188

4.5

Barreiras de Complexidade ....................................................................................... 191

4.5.1

Problemas np-completos: O Problema do Caixeiro Viajante ............................ 191

4.5.2

Problemas indecidveis: O Problema da Correspondncia de Post .................. 198

Notas Finais e Prximos Passos......................................................................................... 204

ndice Remissivo ................................................................................................................ 208

Referncias ........................................................................................................................ 211

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

iv

Aos Professores
Programao de Computadores a disciplina mais tradicionalmente oferecida por
departamentos de Cincia da Computao, e geralmente tambm a de maior nmero de
matrculas. Na UFMG, Programao de Computadores j era oferecida para Cincias e
Engenharias desde antes da criao do departamento. Seu cdigo DCC001, o que d uma
idia de sua venerabilidade.
Este texto parte integrante de um conjunto de materiais pedaggicos para esta disciplina,
produzidos com a inteno de serem usados em um curso de 60 horas-aula, dado em um
semestre letivo. Exerccios, imprescindveis para um bom aprendizado, no esto aqui, mas
em um site Moodle que contm tambm apresentaes e outros materiais.
O enfoque adotado apresenta algumas caractersticas que o distinguem da forma tradicional
como a a disciplina ministrada:

O curso necessita de um professor e de monitores;


Em cada semana so previstas uma aula expositiva, dada pelo professor, e uma aula
prtica, dada pelos monitores;
Aulas expositivas podem ser dadas em auditrio ou sala de aula com grande
capacidade;
Aulas prticas so oferecidas em laboratrios com computadores; melhores resultados
podem ser esperados com turmas pequenas;
Os procedimentos de avaliao do aluno incluem questionrios semanais e provas,
que podem (e devem) ser realizados online;
As aulas prticas tm como objetivo auxiliar os alunos nas avaliaes semanais;
Uma base de questes, fechadas e abertas, est disponvel no Moodle para a
montagem de avaliaes.
Questes fechadas (mltipla escolha, associaes, etc.) so corrigidas
automaticamente; ao montar uma avaliao, o professor deve dosar o uso de
questes abertas para manter o trabalho de correo em volumes aceitveis.
Conjuntos de exerccios podem tambm ser disponibilizados no Moodle, permitindo
estudos e auto-avaliaes pelos alunos;
A linguagem adotada o Scilab;
O primeiro tero do curso dedicado ao ensino de circuitos lgicos e organizao de
computadores, utilizando o software Logisim (Burch, 2002);
Mesmo com um enfoque eminentemente prtico, o material cobre conceitos tericos
fundamentais, como complexidade de algoritmos, problemas np-completos e
problemas indecidveis.

Para justificar a adoo do Scilab preciso falar um pouco sobre o fenmeno MatLab. MatLab,
de Matrix Laboratory, uma linguagem chamada M e um ambiente de desenvolvimento e
execuo voltado para aplicaes tcnicas. Segundo Bill McKeeman (quase fundador do
Computer Science Department de Stanford, hoje professor de Dartmouth e desenvolvedor da
MathWorks(Mathworks), empresa que vende e mantm o MatLab), a linguagem teve origem
na idia de colocar clculos matriciais na sintaxe, ao invs de utilizar chamadas de subrotinas
em Fortran (McKeeman).
Com poucas mas muito bem sucedidas excees, MatLab no conhecido em departamentos
de Cincia da Computao. No s aqui no Brasil que isto acontece. MatLab no foi
projetado por especialistas em linguagens ou compiladores, no tendo aos olhos de cientistas
da computao (incluindo este autor) qualquer importncia conceitual como linguagem de
programao. Mas seu sucesso prtico sem qualquer dvida enorme. Ao apresentar a
Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

v
linguagem M para o MIT em 2005, McKeeman inicia dizendo as it turns out, the computer
science department is about the only part of MIT that does not use MatLab. Ele continua
(McKeeman):
MATLAB has grown over 20 years from academic research into a generalized tool for a
wide variety of applications, including vehicle crash simulation, financial prediction,
genome analysis, imbedded computer control, aircraft design and so on. More than 200
MathWorks developers are working on the next release. Another 1000 people run the rest
of the business, in Natick and worldwide.
There are about a million users. Some MATLAB users do not think of what they are doing as
"programming." Some users are interested in quick and easy results. Some users want to
build applications that are bullet proof and reusable over decades. I know of 100000 line
MATLAB programs and MATLAB programs mining petabytes of data and others running
100x parallel for days at a time. Some universities teach MATLAB for beginning
programming. On every customer contact I find new surprises. MATLAB satisfies all these
communities.
O Scilab um sistema livre, produzido pelo INRIA, que segue a mesma filosofia do MatLab sem
tentar ser um clone. A compatibilidade das linguagens de programao grande mas no
total. Segundo o verbete na Wikipedia, SciLab vem conquistando cada vez mais adeptos tanto
na academia como na indstria. Existem livros sobre SciLab em ingls, francs e espanhol, e
est disponvel na Internet um texto introdutrio em portugus produzido pelo Prof. Paulo
Srgio da Mota Pires, da UFRN. Links para esses materiais podem ser encontrados no site
(Scilab Consortium).

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

vi

Agradecimentos

A nova metodologia para Programao de Computadores (uma aula expositiva e uma aula
prtica por semana) e a nova linguagem (Scilab) nos foram sugeridas pelos Professores Regina
Helena Bastos Cabral e Ivan Moura Campos. Os dois me fizeram conhecer o Matlab, me
convenceram da necessidade de prticas mais intensivas, e tambm da viabilidade de provas
online. A Professora Regina j aplicava estas tcnicas com enorme sucesso em Clculo
Numrico.
Os monitores que trabalharam na disciplina em sua primeira oferta em 2007 foram Maxstaley
Neves e Henrique Chevreux. Sem eles eu no teria conseguido enfrentar a mirade de detalhes
tcnicos do Logisim, Moodle e Scilab, todos ento sistemas novos para mim. Mas, muito mais
do que isso, eles forjaram para a monitoria uma postura ntegra, competente e criativa,
postura que souberam transmitir aos outros monitores: Harlley Augusto de Lima, Phillippe
Samer Lallo Dias, Rafael Bonutti, Douglas Max Duarte Batista, Luis Cludio Dutra Martins,
Rafael Vieira Carvalho e Thiago Moreira Torres.
A aplicao da metodologia faz uso intenso da infra-estrutura de tecnologia da informao da
UFMG, competentemente administrada pelo Centro de Computao, pelo Laboratrio de
Computao Cientfica, pelo Laboratrio de Recursos Computacionais do Instituto de Cincias
Exatas e pelo Centro de Recursos Computacionais do Departamento de Cincia da
Computao.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Introduo

1 Introduo
1.1 Computadores
Este um texto sobre organizao e programao de computadores. Apenas meio sculo aps
a construo dos primeiros computadores, o impacto desta tecnologia sobre nossas vidas
enorme. Computadores mudaram e muito a forma como se faz msica, cinema ou artes
plsticas, como se escrevem textos, como se faz comrcio. A medicina mudou, e mudaram a
engenharia, as cincias, a economia. Mudaram as formas de governar, e as formas de exerccio
de cidadania. Mas o que um computador?
Vamos comear com alguns exemplos. certo que voc j viu diversos computadores, e
provvel que a imagem que lhe venha mente seja similar mostrada na Figura 1.

Figura 1: Um IBM PC, lanado em 1981 (IBM)

Existem computadores que no se assemelham a isto. Alis, os computadores existentes em


maior nmero so simples e pequenos, embutidos em telefones celulares, iPods,
eletrodomsticos e automveis. Outos so enormes, ocupando vastos sales, como o Blue
Gene mostrado na Figura 2. Em 2006 o Blue Gene era o computador mais poderoso do mundo,
sendo capaz de executar 478 trilhes de operaes aritmticas por segundo. Em 2008 j no
era: o RoadRunner, que como o Blue Gene foi produzido pela IBM, atingiu um petaflops, isto
, mil trilhes de operaes aritmticas por segundo. Como curiosidade, o RoadRunner utiliza
chips (circuitos integrados) usados na PlayStation 3 da Sony. A cada seis meses uma lista com
os maiores computadores do mundo publicada no site (Top500). Vale a pena visitar este site,
que contm dados e anlises interessantes sobre a evoluo dos supercomputadores,
denominao que a indstria d a computadores como o Blue Gene ou o RoadRunner.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Introduo

Figura 2: Blue Gene (2006)

Com a rpida evoluo da eletrnica, poderoso hoje, normal amanh, fraco depois de amanh.
Para ter alguma utilidade o termo forosamente relativo poca: um supercomputador
um computador que figura dentre os mais poderosos do mundo ... em sua gerao.

Figura 3: Mark IV (1944)

Neste sentido o Mark IV (Figura 3), de 1944, executando apenas 3 operaes aritmticas por
segundo, era mais super que o Blue Gene, pois era um dos nicos computadores existentes no
mundo.

Figura 4: Mdulos, sub-mdulos, sub-sub-mdulos, ... do Blue Gene

A Figura 4 nos permite entender melhor a estrutura do Blue Gene:

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Introduo

O sistema completo tem 64 racks, pequenas torres que ficam abrigadas nos grandes
blocos do computador.
Cada rack tem 32 ns computacionais.
Um n computacional abriga 16 placas computacionais e, em alguns casos, at 2
placas de entrada e sada de dados.
Cada placa computacional tem duas pastilhas de circuitos integrados.
Cada circuito integrado abriga dois processadores, que so os circuitos que
efetivamente realizam clculos computacionais.

Na Figura 4, as sucessivas decomposies param por aqui , mas, na verdade, o chip palavra
em ingls para pastilha de circuito integrado ainda uma estrutura bastante complexa.

Figura 5: Chip do processador Intel Core 2 Extreme QX9770 (imagem retirada de (HotHardware.com))

Olhando para a foto (Figura 5) de um chip do processador Intel Core 2 Extreme QX9770 ns
podemos perceber visualmente diversos sub-mdulos, mesmo sem ter qualquer idia de suas
funes. Se pudssemos olhar ainda mais de perto, veramos que este chip contm 820
milhes de transistores, espremidos em uma rea de apenas 240 milmetros quadrados.
Fazendo agora um zoom na direo contrria, temos a Internet, a rede mundial que interliga
quase todos os computadores do mundo. A imagem da Figura 6 propositalmente lembra uma
galxia. So milhes de computadores na Internet, todos interligados.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Introduo

Figura 6: Uma visualizao da Internet pelo produzida pelo Projeto Opte (Lyon, 2005). Em azul esto os ns da
Amrica do Norte, em verde os da Europa, Oriente Mdio, sia Central e frica, e em amarelo os da Amrica
Latina.

Todo esse arranjo envolvendo Internet, computadores, processadores, circuitos integrados,


incrivelmente, tudo isso funciona, com algumas falhas, verdade, mas que de forma alguma
impediram a computao de mudar a forma de vida da humanidade. Funciona como? Essa
proeza de organizao se deve exatamente ao uso intenso de uma idia central para a
computao, a modularizao. So muitas e muitas peas, mas que so desenvolvidas
conforme padres que permitem que, para utilizar um mdulo, preciso saber apenas o que
esse mdulo faz, e no como ele construdo.
Mdulos permitem a diviso de competncias. Um programador profissional normalmente
no tem a menor idia sobre a fsica de semicondutores, e nem mesmo sobre como funcionam
os protocolos bsicos da Internet. Toda a computao um imenso lego, onde cada pea tem
encaixes bem definidos que permitem seu acoplamento para a montagem de estruturas
maiores. Como veremos ao longo desse curso, mdulos so onipresentes na cincia da
computao, pois so fundamentais para o domnio de sistemas complexos.

1.2 Informao Analgica e Informao Digital


Computadores s trabalham com informao, e por isso que a palavra informtica
sinnimo de cincia da computao. Mas informao um conceito de difcil definio. algo
em um objeto o objeto suporte que diz alguma coisa sobre outro objeto o objeto alvo
ou sobre uma grandeza fsica, ou sobre um evento localizado no tempo, ou sobre qualquer
coisa. Quando o objeto suporte da informao tem uma relao fsica direta com o objeto alvo
da informao, ns dizemos que a informao ali armazenada informao analgica. Quando
o objeto suporte armazena smbolos como nmeros ou palavras com informao sobre o
objeto alvo, ns dizemos que a informao simblica ou, mais comumente, informao
digital.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Introduo

Figura 7: Filmes fotogrficos (Flickr)

Um filme fotogrfico revelado objeto em extino nos dias de hoje registra informao
sobre a cena fotografada. Um arquivo JPEG, formato comum para imagens digitais, tambm
tem. Uma mesma cena, fotografada com uma mquina tradicional, gera informao analgica
sobre o material foto-sensvel que cobre o filme; fotografada com uma mquina digital, gera
smbolos, ou seja, informao digital.

Figura 8: Informao analgica e digital

Um termmetro caseiro um objeto que fornece informao sobre a temperatura do ar, ou


do corpo de uma criana, pois fenmenos de dilatao fazem com que a altura da coluna de
mercrio seja proporcional temperatura medida. Ns dizemos que a informao obtida por
um exame direto do termmetro uma informao analgica.

Ponto de ebulio
da gua

Corpo humano
Ponto de fuso
do gelo

Figura 9: Um termmetro

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Introduo

Com o uso de uma escala um mdico pode anotar em um papel a temperatura de seu
paciente. Ao faz-lo, a informao sobre a temperatura passa de analgica (a altura da coluna
de mercrio) para informao digital ou simblica (o nmero anotado pelo mdico).

Ponto de ebulio
da gua

Corpo humano

Ponto de fuso
do gelo

Figura 10: Um termmetro com escala

Existe uma perda nessa transformao: o mdico ir anotar o nmero correspondente ao


tracinho mais prximo extremidade da coluna, talvez com uma proximao entre dois
tracinhos, mas no a sua altura exata. Para o mdico essa perda perfeitamente
tolervel.Temperaturas do corpo humano medidas com uma casa decimal provavelmente
atendem a todas as necessidades clnicas. E existe tambm um grande ganho: a temperatura
anotada informao simblica, que pode ser comunicada ao telefone, ou copiada em outro
papel ou digitada em um computador.

Ponto de ebulio
da gua

50

Corpo humano
50

Ponto de fuso
do gelo

Figura 11: Termmetro com escalas Celsius e Farenheit

O uso de informao simblica requer uma conveno de interpretao. A qual temperatura


altura da coluna de mercrio corresponde o smbolo 50? A Figura 11 mostra as escalas mais
comumente utilizadas para temperaturas. Ou seja, ao dizer 50 graus, devemos esclarecer se
estamos falando de graus centgrados ou Farenheit, ou de alguma outra escala de
temperaturas.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Introduo

7
Tabela 1: Diferentes smbolos para os nmeros inteiros de 1 a 7

Arbico
1
2
3
4
5
6
7

Romano
I
II
III
IV
V
VI
VII

Binrio
1
10
11
100
101
110
111

Smbolos podem tambm ser usados para representar outros smbolos. Assim como explicitar
uma escala um requisito para se interpretar um nmero associado a uma temperatura, a
correspondncia entre smbolos deve ser estabelecida por convenes, como mostra o
exemplo na Tabela 1.

1.3 Computadores e Informao


Computadores so essencialmente formados por processadores, memrias, sensores e
atuadores:

O componente mais importante o processador. Um processador transforma


informao exclusivamente simblica, em informao tambm simblica; as
transformaes que um processador realiza so ditadas por um programa que o
processador executa.
Memrias servem para registrar informaes para recuperao posterior, e tambm
s trabalham com informaes simblicas.
Sensores como o teclado do computador, o mouse, cmeras digitais, microfones
digitais, entradas de rede, so tambm chamados de dispositivos de entrada, e trazem
informao para o processador.
Atuadores so impressoras, monitores de vdeo, alto-falantes, projetores, sadas de
rede, e so tambm chamados de dispositivos de sada. Atuadores exportam
informao que sai do processador.
Sensores e atuadores frequentemente trabalham tanto com informao digital como
com informao analgica, e fazem uso de converses A/D e D/A.

A informao digital nos processadores e memrias atuais utiliza somente dois valores bsicos
para os smbolos. A palavra bit designa a unidade de informao simblica; os dois valores de
um bit so normalmente denotados por 0 e 1.
Dois valores s? Computadores fazem maravilhas: exibem filmes, oferecem jogos, editores de
texto, correio eletrnico. Como, somente com 0 e 1? que, mesmo se cada um s contm um
de dois smbolos, computadores usam muitos bits. Com 1 bit podemos representar dois
estados, que podem por conveno representar 0 ou 1, sim ou no, verdadeiro ou falso, preto
ou branco, o que quer que se convencione, mas apenas dois estados. Com dois bits j so 4
combinaes: 00, 01, 10 e 11. Com 3 bits, 8 combinaes: 000, 001, 010, 011, 100, 101, 110 e
111. J fica possvel armazenar 8 diferentes informaes, que poderiam ser os inteiros de 0 a
7, ou talvez designando 8 diferentes nveis de cinza: o preto, o branco, e 6 nuanas
intermedirias.
No difcil ver que, ao acrescentar um bit a um conjunto de bits, multiplicamos por 2 o
nmero de combinaes j existentes. Ou seja, com bits, temos
combinaes, e
cresce
muito rapidamente:
Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Introduo

Com 8 bits podemos representar


coisas diferentes. Isso suficiente para
atribuir um cdigo distinto para cada letra do alfabeto, distinguindo entre maisculas
e minsculas, e tambm para caracteres especiais como (, +, etc. Um conjunto de
8 bits chamado de byte.
Com 24 bits, temos
possibilidades, o suficiente para representar
todas as cores com qualidade excelente para a acuidade visual humana.
Com 80 bits, nada menos que
coisas
podem ser representadas!

A Tabela 2 mostra os prefixos usados para designar potncias decimais e binrias de uso
corrente na computao.
Tabela 2: Prefixos binrios e decimais.
Prefixo
kilo
mega
giga
tera
peta
exa
zetta
yotta

Smbolo
k/K
M
G
T
P
E
Z
Y

10

2
220
230
240
250
260
270
280

=
=
=
=
=
=
=
=

1
1
1
1
1
1
1
1

024
048
073
099
125
152
180
208

576
741
511
899
921
591
925

824
627
906
504
620
819

Prefixos Binrios e Decimais


Valor
Base 10
> 103 = 1,000
> 106 = 1 000 000
> 109 = 1 000 000 000
776
> 1012 = 1 000 000 000 000
842 624
> 1015 = 1 000 000 000 000 000
606 846 976
> 1018 = 1 000 000 000 000 000 000
717 411 303 424
> 1021 = 1 000 000 000 000 000 000 000
614 629 174 706 176
> 1024 = 1 000 000 000 000 000 000 000 000

Podemos ver que o uso de apenas 2 smbolos no traz limitao alguma de representatividade.
Tudo bem, mas porque s 2 smbolos? Se os computadores fossem menos mesquinhos e
usassem, por exemplo, os algarismos decimais como unidade bsica de informao, no
teramos um sistema que, antes de qualquer coisa, seria familiar, e que com algarismos
poderamos representar
coisas diferentes?
A deciso de adoo de um sistema binrio foi tomada pelos projetistas dos primeiros
computadores, e se justifica principalmente pela confiabilidade. Computadores so
equipamentos eletrnicos, onde smbolos devem ser representados por voltagens ou
correntes eltricas. Se tivermos apenas dois nveis de voltagens ou de correntes, a distino
dos smbolos fica muito mais confivel.
Alm disso, bits so baratos, e ocupam muito pouco espao quando anotados em suportes
eletrnicos. O notebook utilizado para escrever este texto tem 2GB (2 Giga Bytes) de memria
principal, e 300GB de capacidade de armazenamento em sua memria secundria, um disco
magntico.

1.4 Converses anlogo-digital e digital-analgica

Figura 12: Converses anlogo-digital (A/D) e digital-analgica (D/A)

Existem dispositivos que transformam informao analgica em informao digital (converses


A/D), e outros que fazem o contrrio (converses D/A).

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Introduo

Figura 13: Um sinal analgico sinoidal

Para digitalizar um sinal de entrada como o da Figura 13 preciso obter amostras de sua
amplitude em instantes discretos no tempo, e digitalizar obter um valor numrico cada
amostra.

Figura 14: Sinal original e sinal amostrado nos instantes correspondentes aos traos verticais em vermelho,
usando 8 bits e frequncia de amostragem de 41,67 MHz

A Figura 14 ilustra esse processo de digitalizao. Se reconstituirmos este sinal a partir dos
valores das amostras, mantendo constante o valor do sinal nos intervalos de tempo entre duas
amostras, iremos obter o sinal direita na figura. Sem dvida, o sinal reconstitudo se
assemelha ao sinal original, mas a m qualidade da digitalizao evidente.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Introduo

10

Figura 15: Digitalizao com frequncia de amostragem insuficiente, produzindo um sinal completamente
distorcido. Sinal amostrado com 8 bits e frequncia da amostragem 6,17 MHz

A qualidade da digitalizao depende:

da freqncia da amostragem e
da preciso com que feita cada amostragem.

Se diminuirmos a freqncia de amostragem o resultado pode ser desastroso, como mostrado


na Figura 15; se aumentarmos, a qualidade melhora.

Figura 16: A qualidade da digitalizao melhora com a frequncia de amostragem. Sinal amostrado com 8 bits e
frequncia de amostragem de 200 MHz

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Introduo

11

Na Figura 16 vemos o mesmo sinal sendo digitalizado com uma freqncia de amostragem
bem maior. O sinal amostrado j est bem prximo do sinal original. Podemos sempre tentar
aumentar a freqncia de amostragem, mas isso tem custos. Se considerarmos que o sinal
est sendo amostrado para apreciao visual por humanos, a partir de um certo ponto a
qualidade da digitalizao atingir os nossos limites de acuidade visual.
Como dissemos, a preciso com que a amplitude do sinal em cada amostra digitalizada
tambm influi na qualidade da converso.

Figura 17: Sinal amostrado com f = 200 MHz, mas com apenas 2 bits de resoluo

Na Figura 17 ns vemos o efeito do uso de apenas dois bits para a digitalizao da amplitude
em cada amostra, e na Figura 18 a digitalizao com um nico bit.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Introduo

12

Figura 18: Sinal amostrado com f = 200 MHz, com um nico bit de preciso

As ilustraes da Figura 13 Figura 18 foram obtidas com o software ADconversion, que voc
pode obter no site (Lohninger, 2006). Faa o download, brinque com os parmetros da
digitalizao (freqncia de amostragem e bits de preciso), e veja os resultados.
importante observar que a converso em qualquer dos dois sentidos nunca perfeita, mas
em muitos casos pode ser to boa quanto se queira. Em converses D/A (Digital/Analgica)
destinadas absoro por humanos, a explorao de limites fisiolgicos como a acuidade
visual ou auditiva muito utilizada.

1.5 Sensores e atuadores

Figura 19: Computadores, programas e informao digital

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Introduo

13

Programas so escritos por pessoas e executados por computadores. Programas so


compostos por instrues e comandos que lm, transformam e registram informao digital.

Figura 20: Sensores e atuadores

A informao digital recebida pelo computador por sensores (ou equipamentos de entrada)
e, normalmente aps alguma transformao, enviada para atuadores (ou equipamentos de
sada).

Figura 21: Interao homem-mquina

A interao entre humanos e computadores tambm se d atravs de sensores e atuadores.


Presente em quase todos os computadores, o sensor mais comum o teclado. Sua
importncia imensa. atravs de teclados que entra, por exemplo, a informao que
movimenta a economia mundial. O teclado pode ser tambm uma barreira pessoal para a
entrada no mundo da informtica. Pessoas com dificuldades na digitao tendem a abandonar
os computadores, em uma atitude que provavelmente lhe traro conseqncias negativas.

Figura 22: Barbara Blackburn, recordista mundial de velocidade de digitao(BarbaraBlackburn), e um teclado


Dvorak, projetado para maximizar a velocidade de digitao em ingls

Outras pessoas, pelo contrrio, tm grande facilidade para a digitao. O recorde mundial de
digitao pertence a Barbara Blackburn, que atingia uma velocidade sustentada de 15 toques
por segundo, com picos de 20 toques por segundo, usando um teclado Dvorak. Estamos nos
permitindo essa digresso somente para calcular a velocidade de produo de informao por
Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Introduo

14

um teclado. Considerando que cada toque produz um byte ou 8 bits, a Barbara Blackburn
produzia informao a uma taxa de 160 bps (bps = bits por segundo).

Figura 23: Sensores especiais: um rdio-telescpio e um acelerador de partculas

A cincia faz uso de sensores que produzem informao muito mais rapidamente. Um rdiotelescpio ou um acelerador de partculas podem produzir informao taxas de 1Gbps, ou
seja, um bilho de bits por segundo, quase 7 milhes de vezes mais rpido do que o recorde
mundial de digitao.

Figura 24: Um atuador especial: um brao mecnico

Atuadores comuns so monitores, impressoras, alto-falantes. Existem tambm atuadores


especiais como braos mecnicos usados por robs, como mostrado na Figura 24.

Figura 25: Redes de computadores

Entradas e sadas de rede so particularmente importantes pois permitem a conexo entre


computadores. Um atuador de um computador emite sinais eltricos, ou de rdio, ou ticos,
que so percebidos lidos por um sensor de outro computador.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Introduo

15

1.6 Memrias
Memrias so usadas por computadores para registrar informaes para recuperao
posterior. Um computador geralmente trabalha com diversos tipos de memria, que seguem
uma distribuio hierrquica:

Registradores so memrias muito pequenas e muito rpidas, que se encontram


dentro do mesmo chip do processador, e que tm suas entradas e sadas ligadas
diretamente a circuitos que realizam transformaes de informao, como a unidade
aritmtica que, como o nome indica, realiza operaes aritmticas.
Memria principal ou RAM (Random Access Memory) um circuito externo ao
processador, mas de acesso ainda bastante rpido. Instrues executadas pelo
processador utilizam diretamente operandos armazenados na memria principal.
Transformaes como operaes aritmticas geralmente exigem que informao seja
previamente transferida da memria principal para registradores, onde as operaes
so realizadas, e os resultados posteriormente armazenados na memria principal. De
uma forma geral a memria principal voltil, no sentido em que necessrio manter
o computador ligado para que a informao ali armazenada no se perca. A
volatilidade no uma necessidade, mas uma caracterstica da tecnologia empregada
nas memrias principais atuais. H alguns anos atrs memrias principais utilizavam
ncleos de ferrite, com o registro da informao feito por polarizaes magnticas no
volteis.

Figura 26: 4GB de RAM montados em um computador pessoal

Memrias secundrias so tipicamente discos rgidos, onde informaes tambm


podem ser lidas e escritas, mas o processador deve executar instrues especiais de
entrada e sada para isso. Memrias flash (memrias usadas em pen drives, no iPod)
vm sendo tambm cada vez mais utilizadas como memrias secundrias. Memrias
secundrias so no-volteis, com a informao armazenada permanecendo
registrada mesmo sem qualquer alimentao de energia. A informao em uma
memria secundria sempre formatada em arquivos e diretrios, que provm uma
abstrao essencial para o seu uso.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Introduo

16

Figura 27: Um disco rgido sem a cobertura protetora, mostrando o movimento da cabea de leitura e gravao

Memrias tercirias so necessrias em ambientes maiores, que armazenam grandes


volumes de dados. Fitas magnticas so utilizadas, com um rob que capaz de
localizar a fita correta em um repositrio e mont-la em uma unidade de fita ligada ao
computador.

Figura 28: Armazenamento tercirio com uma grande coleo de fitas magnticas manipuladas por um brao
mecnico de um rob

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Introduo

17

1.7 Organizao do Texto


Este material destina-se a disciplinas introdutrias de organizao e programao de
computadores para alunos de cincias e de engenharia, e tem como objetivos:

introduzir noes bsicas de circuitos digitais, organizao de computadores,


representao de dados e programao,
apresentar ao aluno alguns princpios bsicos da construo de algoritmos mtodos
computacionais para transformao de informao e de sua implementao em um
ambiente de programao, e
tornar o aluno fluente no uso de uma ferramenta computacional, o Scilab, de vasta
aplicao nas cincias e engenharias.

O material est dividido em trs partes:

1.7.1

Parte I: Organizao de Computadores


Parte II: Ambiente e Linguagem Scilab
Parte III: Algoritmos e Programas
Organizao de Computadores

A Parte I, Organizao de Computadores, tem dois objetivos principais:

dar ao aluno uma compreenso dos elementos essenciais do funcionamento interno


de um computador, e
permitir ao aluno perceber a dificuldade da programao em baixo nvel, e apreciar os
ganhos obtidos com o uso de compiladores e interpretadores

A interpretao de conjuntos de bits estabelecida por convenes de cdigos que associam a


uma determinada configurao de bits um valor numrico, ou um nvel de vermelho em uma
imagem. So apresentados alguns dos cdigos mais comumente utilizados na computao.
Circuitos combinatrios, isto , circuitos digitais que realizam transformaes sobre um
conjunto de bits de entrada produzindo outro conjunto de bits como sada, no tm memria,
e sua sada em um dado instante funo apenas dos valores de entrada nesse instante.
Circuitos combinatrios utilizam portas lgicas, que so componentes que realizam as
operaes AND, OR e NOT que constituem a lgebra de Boole. So vistos circuitos
combinatrios para somas, comparaes e para direcionamento de fluxo de dados.

Figura 29: Circuito combinatrio, simulado no Logisim, que realiza a soma de duas parcelas binrias de 4 bits

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Introduo

18

Circuitos seqenciais tm a sua sada influenciada tambm pelo valor corrente de suas
memrias. O elemento bsico de memria o flip-flop, capaz de armazenar um bit. Conjuntos
de flip-flops formam registradores, que so ligados a outros registradores e a circuitos
combinatrios por meio de barramentos. So tambm introduzidos circuitos de memrias
onde ficam armazenados dados e programas. Osciladores e registradores circulares so
introduzidos como elementos para controle da evoluo temporal de um circuito.

Figura 30: Circuito sequencial, simulado no Logisim, que acumula a soma das entradas.

A primeira parte culmina com a apresentao da arquitetura de um processador simples, com


suas rotas de dados, instrues e seu ciclo de execuo, sua unidade de controle e tambm
software para sua programao em linguagem Assembler.
1.7.2

Linguagem e Ambiente Scilab

O estudo da organizao de computadores ter permitido ao aluno tanto conhecer melhor o


funcionamento bsico de um computador, como ter um contato com a desumanidade da
programao a nvel de instrues de mquina de um computador. A Parte II, Linguagem e
Ambiente Scilab, tem como objetivos principais:

a introduo de uma linguagem de alto nvel, Scilab (Scilab Consortium), que facilita
imensamente a tarefa de programao de computadores atravs da oferta de
comandos com formato muito mais prximo da forma como seres humanos
raciocinam, e
a familiarizao do aluno com o ambiente de desenvolvimento e de execuo de
programas fornecido pelo Scilab.

Inicialmente apresentado o Scilab como uma linguagem de alto nvel, com variveis,
expresses aritmticas e comandos de atribuio.So vistas variveis que contm valores
numricos ou cadeias de caracteres. Em seguida so apresentadas construes de linguagem
para expressar comportamentos condicionais e repetitivos.
Matrizes constituem o ponto forte do Scilab. Ns veremos como criar e modificar matrizes,
aritmtica matricial, como construir matrizes a partir de matrizes j existentes, e uma srie de
outras operaes. Um uso freqente de matrizes no Scilab para a construo de grficos,
feita por comandos muito flexveis.
Em seguida so vistos comandos para a manipulao de arquivos, que so conjuntos de dados
que tipicamente so produzidos por um programa e armazenados em um disco rgido ou um
pen drive, e lidos posteriormente por outro programa. Arquivos so absolutamente essenciais
para o tratamento de grandes volumes de dados.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Introduo

19

A Parte II se encerra com o estudo de funes Scilab, que constituem uma ferramenta
essencial para o uso de mdulos na construo de programas.
Para exemplificar o uso do Scilab para a construo de programas, consideremos o seguinte
problema. Temos um arquivo ondas.txt (fonte: (StatLib, 1989) )que contm dados obtidos
em um laboratrio de observao de ondas marinhas (Figura 31).

Figura 31: O arquivo ondas1.txt visto com o Bloco de Notas

Cada linha do arquivo contm uma medida do nvel do mar; a aparelhagem do laboratrio
permite fazer 30 medidas por segundo. O arquivo completo tem 4096 linhas. Ns queremos
um programa para obter um grfico com os pontos do arquivo, e tambm saber os valores
mximo e mnimo presentes na amostra.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Introduo

20
Funes utilizadas

// Programa da Onda
getf("Minimo.sci");
Leitura do arquivo
getf("Maximo.sci");
arq = xgetfile();
Gerao do grfico
Onda = fscanfMat(arq);
Sada
plot2d(Onda);
printf("Min = %5.2f, Max = %5.2f",...
Minimo(Onda), Maximo(Onda));
Figura 32: O programa Scilab Onda.sci. Cada linha um comando, a no ser que termine em .... Linhas que se
iniciam com // so comentrios que se destinam a leitores humanos.

A Figura 32 mostra um programa Scilab que faz isso, utilizando dois mdulos, as funes
Maximo e Minimo, mostradas na Figura 33.

Figura 33: As funes Maximo e Minimo vistas no editor Scipad

Para entender melhor essas funes, veja o algoritmo descrito na Seo 1.7.3. O programa
produz o grfico da Figura 34, e a sada Min = -0.86, Max = 0.36 mostrada na
console do Scilab.

Figura 34: Grfico com os pontos no arquivo ondas1.txt

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Introduo
1.7.3

21

Algoritmos e Programas

Na parte III, Algoritmos e Programas, nosso foco se afasta um pouco de especificidades da


linguagem Scilab para abordar aspectos da programao de computadores que so
independentes da linguagem utilizada. Ns continuamos a usar o Scilab, mas o contedo dessa
parte seria essencialmente o mesmo se estivssemos utilizando C, Java, Fortran ou qualquer
outra linguagem.
Ns veremos que um algoritmo um mtodo para transformao de informao de entrada
em informao de sada, e que em boa parte independente da linguagem particular em que
est descrito. A transformao desejada definida por uma especificao que resulta de uma
anlise de um problema.

A = [39. 24. 50. 42. 28. 8. 62. 34. 70.

52.];

Figura 35: Como encontrar o menor valor em uma coleo de nmeros?

Como um exemplo, queremos encontrar o menor valor presente em uma coleo de nmeros.
Com 10 nmeros, como mostrados na Figura 35, fcil; podemos faz-lo por inspeo visual.
Mas como encontrar o menor valor entre, digamos, 50.000 nmeros? Para isso precisamos de
um algoritmo, isto , de um mtodo que tenha como informao de entrada a coleo de
nmeros, e como sada o menor valor ali presente.
Em programao uma coleo de nmeros chamada vetor. O primeiro elemento de um vetor
notado
; o quinto,
; o -simo,
. Queremos portanto construir um algoritmo
que encontre o menor valor em um vetor de tamanho arbitrrio. Para isso, vamos comear
com o caso mais simples possvel: um vetor com um nico elemento, que obviamente o
menor elemento presente no vetor. Tudo bem, mas queremos trabalhar com vetores grandes
de verdade.
Para avanar, usamos induo. Suponhamos que, de alguma forma, descobrimos que o menor
valor entre os primeiros elementos de um vetor de tamanho . Podemos ento inferir
que o menor valor entre os
primeiros elementos de o menor entre e
.
Como j sabemos encontrar o mnimo em um vetor de 1 elemento (
), sabemos
encontrar o mnimo em um vetor com 2 elementos; como sabemos encontrar o mnimo em
um vetor de 2 elementos, sabemos encontrar o mnimo em um vetor com 3 elementos.
Prosseguindo com o raciocnio, j temos um algoritmo para encontrar o menor valor em um
vetor de tamanho arbitrrio. Tendo um algoritmo, no temos mais medo do problema com
50.000 nmeros. Nosso trabalho ser programar o algoritmo; caber ao computador a sua
execuo.
A = [39.

24.

50.

42.

28.

8.

62.

34.

70.

52.];

A = [39.

24.

50.

42.

28.

8.

62.

34.

70.

52.];

A = [39.

24.

50.

42.

28.

8.

62.

34.

70.

52.];

A = [39.

24.

50.

42.

28.

8.

62.

34.

70.

52.];

A = [39.

24.

50.

42.

28.

8.

62.

34.

70.

52.];

A = [39.

24.

50.

42.

28.

8.

62.

34.

70.

52.];

Figura 36: Seis primeiros passos do algoritmo que encontra o menor valor presente em um vetor

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Introduo

22

Um algoritmo dito correto quando atende sua especificao. Dois algoritmos corretos
podem satisfazer uma mesma especificao, mas diferir substancialmente na eficincia (gasto
de tempo e de recursos computacionais como memria) com que realizam a transformao de
informao desejada. O termo complexidade empregado para designar a eficincia (ou
melhor, o inverso da eficincia) de um algoritmo para a soluo de um problema.
A complexidade de algoritmos estudada inicialmente com dois problemas clssicos da cincia
da computao: a ordenao dos elementos de um vetor e a busca por um elemento de um
vetor com valor igual a uma chave dada. Para cada um desses problemas so vistos algoritmos
que diferem em sua complexidade.
Encontrar uma raiz de uma funo ou resolver um sistema de equaes lineares so exemplos
de problemas numricos que um cientista ou engenheiro frequentemente tem que resolver.
Ns veremos alguns exemplos de algoritmos que resolvem problemas desse tipo, e tambm
alguns cuidados que devem ser tomados ao se desenvolver programas para estas aplicaes.
Algoritmos com melhor complexidade so fruto de engenho e arte de seus projetistas. Existem
entretanto problemas cuja soluo algortmica intrinsecamente difcil, no sentido em que
no existem boas solues para eles. A Parte III e o curso se encerram com exemplos de
problemas computacionalmente difceis, e de problemas para os quais simplesmente no
existe nenhum algoritmo que os resolvam para todos os casos.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

23

2 Organizao de Computadores
2.1 Bits e cdigos
Como j dissemos, informao simblica exige convenes de interpretao. Qualquer pessoa
pode dar a um conjunto de bits a interpretao que bem entender, mas a escolha de um
cdigo pode ter conseqncias importantes.
O Cdigo ASCII. Para a comunicao de dados entre computadores a adoo de cdigos com
aceitao mais ampla traz diversas vantagens. O cdigo ASCII American Standard Code for
Information Interchange uma dessas convenes de ampla aceitao em toda a indstria
da computao.
A Tabela 3 mostra partes do cdigo ASCII, adotado desde os anos 60 para a representao de
caracteres como A, a, (, +, etc., para o espao em branco (sim, o espao exige uma
representao), e para os chamados caracteres de controle, como line feed, para indicar uma
troca de linhas. O cdigo ASCII oficial usa 7 bits, o que permite
combinaes. Tendo
sido proposto por norte-americanos no incio da era dos computadores, no de se estranhar
que ali no haja proviso de cdigo para caracteres acentuados ou cedilhas. Estes so
contemplados no cdigo ASCII estendido, que usa 8 bits para representar 256 caracteres.
Tabela 3: Exemplos do cdigo ASCII
Caractere
End of Transmission
Line Feed
Space
(
+
0
1
2
3
A
B
C
a
b
c

Cdigo
0000100
0001010
0100000
0101000
0101011
0110000
0110001
0110010
0110011
1000001
1000010
1000011
1100001
1100010
1100011

Decimal
4
10
32
40
43
48
49
50
51
65
66
67
97
98
99

Binrios sem Sinal. Um outro critrio para a escolha de um cdigo a sua adequao para
operaes aritmticas. No cdigo ASCII estendido o nmero decimal 123 representado pela
seqncia de 24 bits 00110001 00110010 00110011, onde colocamos espaos para facilitar a
leitura. Para nmeros, a interpretao de um conjunto de bits como um nmero binrio leva a
cdigos mais compactos e que, como veremos, permitem a realizao de operaes de soma
por circuitos mais simples, mais rpidos e mais baratos.
Tabela 4: 10 primeiras potncias de 2

10

16

32

64

128

256

512

1024

O decimal 123 pode ser representado em binrio por 1111011, utilizando apenas 7 bits. Esta
representao vem do fato que
.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

24

Tabela 5: Representao dos nmeros de 0 a 15 como binrios sem sinal de 4 bits

Decimal
Binrio

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111

A converso de
binrio-decimal:

para

pode ser feita com o seguinte mtodo para converso

Ns precisamos expressar 123 como uma soma de potncias de 2. Para isso,


procuramos em uma tabela de potncias de 2 (como a Tabela 4; a tabela deve chegar
at uma potncia de 2 maior que o nmero a ser convertido) o maior valor que no
exceda 123 o que, no caso, 64. Temos
.
Temos agora que expressar 59 como uma soma de potncias de 2. Na Tabela 4, a
maior potncia de 2 que no excede 59 32. Repetindo o raciocnio, temos
.

Desta forma progredimos at que a parcela a ser expressa como soma de potncias de 2 seja
igual a zero.
Tabela 6: Converso do decimal 123 para binrio
A converter
Potncia de 2

123
64

59
32

27
16

11
8

3
2

1
1

Um uso comum de nmeros representados como binrios sem sinal o sistema RGB (Red,
Green, Blue) para a codificao da cor associada a um pixel um ponto em um monitor com
os valores dos nveis de intensidade das cores primrias componentes vermelho, verde e azul.
Para cada uma dessas cores utiliza-se um byte (8 bits), o que permite representar nveis de
intensidade entre 0 e 255. Essa preciso considerada satisfatria para a nossa acuidade
visual.

Figura 37: Uso de binrios sem sinal para a representao dos nveis de intensidade das cores primrias vermelho
(Red), verde (Green) e azul (Blue), conhecido como RGB

Sinal e Amplitude. Como computadores s usam bits, ns no podemos usar um sinal - para
indicar que um valor negativo. Temos que usar bits para codificar essa informao. A
codificao para nmeros negativos conhecida como sinal e amplitude bastante natural.
Basta tomar o bit mais esquerda e interpret-lo como o sinal do nmero: se for 0, o nmero
cuja amplitude representada pelos bits restantes positivo, e se for 1, negativo. Portanto, se
tivermos 8 bits, o bit mais esquerda ser usado para codificar o sinal. Os 7 bits restantes nos
permitem representar amplitudes entre 0 e 127, ou seja, podemos, com os 8 bits, representar

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

25

os inteiros entre -127 e +127. Repare que zero tem duas representaes: 10000000 e
00000000.
Codificao com Deslocamento. Uma outra possibilidade para representar nmeros negativos
est ilustrada na Tabela 7. A conveno adotada de interpretar um conjunto de bits como a
representao de um valor igual ao valor de sua interpretao como binrio sem sinal,
deslocado por um fator a ser subtrado.
Tabela 7: Representao de nmeros negativos por deslocamento

Decimal
0
1
2
3
4
5
6
7

Binrio
000
001
010
011
100
101
110
111

Nmero
-3
-2
-1
0
1
2
3
4

Complemento de 2. A absoluta maioria dos computadores utiliza entretanto uma codificao


conhecida como complemento de 2 para a representao de nmeros inteiros negativos. A
Tabela 8 mostra a codificao em 3 bits dos inteiros entre -4 e 3 usando complemento de 2.
Tabela 8: Codificao em complemento de 2 com 3 bits

b2
0
0
0
0
1
1
1
1

Complemento de 2
Bits
b1
b0
0
0
1
1
0
0
1
1

O valor representado pela sequncia de bits

0
1
0
1
0
1
0
1

Valor
0
1
2
3
-4
-3
-2
-1

dado pela frmula


.

(Ns adotaremos neste texto a conveno de designar sempre por o bit menos significativo
e por o bit mais significativo de uma sequncia de bits.) O valor representado por 101 ,
portanto, dado por
.
Voc pode estar se perguntando como que algum pode preferir usar complemento de 2,
sendo que as propostas anteriores so mais simples e intuitivas. A resposta simples, e
decisiva para todos os fabricantes de computadores: a representao em complemento de 2
tem propriedades que permitem uma grande economia na construo de circuitos. Para se
obter o complemento de um nmero, basta complement-lo bit a bit, e somar 1. Por exemplo,
2 representado por 010; complementando bit a bit, obtemos 101; somando 1, chegamos a
110, que a representao de -2. Isso permite aos fabricantes aproveitar para fazer
subtraes o mesmo circuito utilizado para fazer somas, com acrscimos mnimos de
hardware.
Ponto Flutuante. A representao em um nmero limitado de bits de valores muito grandes
ou muito pequenos utiliza mecanismos para sua codificao similares aos que usamos na
notao cientfica com potncias de 10. O nmero de Avogadro, por exemplo, notado por
Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

26

, e o dimetro de um tomo de hidrognio de


metros. Para o nmero
de Avogadro ns dizemos que a mantissa 6,02 e o expoente, 23. A codificao de nmeros
em ponto flutuante atribui a alguns dos bits do nmero o significado de um expoente no de
10 mas de 2, como no poderia deixar de ser.
Existe um padro para ponto flutuante de aceitao total pela indstria que o IEEE 754. Para
nmeros de preciso simples, o IEEE 754 utiliza 32 bits, sendo 1 bit para o sinal (0 = positivo, 1
= negativo), 8 para o expoente e 23 para a mantissa. Para preciso dupla so 64 bits: 1 para o
sinal, 11 para o expoente e 52 para a mantissa. Expoentes negativos so representados pela
conveno de deslocamento que j vimos. Notando por o sinal, por o valor do expoente
interpretado como um binrio sem sinal, e por o valor da mantissa, tambm interpretada
como um binrio sem sinal, o valor representado por um nmero em ponto flutuante padro
IEEE 754 dado por

onde o deslocamento usado para expressar expoentes negativos, valendo 127 para
preciso simples e 1023 para preciso dupla.
A Figura 38 mostra um nmero em ponto flutuante de 32 bits.
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10

22 21 20 19 18 17 16 15 14 13 12 11 10

-1
128
64
0
16
0
4
0
1
4194304
2097152
1048576
0
262144
131072
65536
0
16384
0
4096
2048
1024
0
256
0
0
0
16
0
0
0
1

1 1 1 0 1 0 1 0 1 1 1 1 0 1 1 1 0 1 0 1 1 1 0 1 0 0 0 1 0 0 0 1

213

7822609
-6,052450558E+32

= (-1)1.7822609.2(213-127)

E+32 significa 1032

Figura 38: Um nmero em ponto flutuante com 32 bits

O padro IEEE 754 reserva expoentes s com 1s e s com 0s para a representao de valores
especiais como
ou NAN (Not a Number), que so necessrios para a comunicao de
resultados de certas operaes ou do clculo de algumas funes. A referncia (Hollasch,
2005) tem um bom resumo do padro.

2.2 Circuitos Combinatrios


Vimos at agora como representar nmeros, caracteres , cores e qualquer outra coisa
utilizando bits. Nesta seo ns iremos ver como que os circuitos em um computador
transformam informao, como em um circuito de soma que recebe como entrada dois
conjuntos de bits, e produz como sada um outro conjunto de bits com a representao do
valor da soma das entradas.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores
2.2.1

27

lgebra de Boole

Figura 39: George Boole, 1820-1898

Em 1854 o matemtico ingls George Boole props uma lgebra para o clculo da validade de
expresses formadas por proposies lgicas. Essa lgebra chamada hoje de lgebra
Booleana, e constitui a base para o projeto de circuitos digitais. Ela trabalha com variveis
lgicas, isto , com variveis que podem ter somente os valores verdadeiro ou falso, ou 1 ou 0.
As operaes fundamentais da lgebra de Boole so NO, E e OU, mais conhecidas pelas
palavras em ingls NOT, AND e OR. Essas operaes fundamentais, ou melhor, composies
dessas operaes fundamentais constituem as nicas transformaes feitas por qualquer
computador sobre bits.

2.2.2

Portas Lgicas
Tabela 9: Definio das operaes NOT, OR e AND

a
0
1

NOT a
1
0

a
0
0
1
1

b
0
1
0
1

a OR b
0
1
1
1

a
0
0
1
1

b
0
1
0
1

a AND b
0
0
0
1

A Tabela 9 mostra as definies dessas operaes. O que se v nas tabelas bastante intuitivo:

A operao de negao (NOT) simplesmente inverte o valor de entrada;


A operao OR tem como resultado 1 se pelo menos uma das entradas for igual a 1, e
s igual a 0 quando todas as entradas forem iguais a 0;
Inversamente, a operao AND tem 0 como resultado se qualquer uma das entradas
for igual a 0, e s igual a 1 quando todas as entradas forem iguais a 1.

Circuitos digitais que implementam operaes booleanas so conhecidos como portas lgicas.
A Figura 40 mostra um circuito simulado no Logisim contendo entradas, sadas e portas NOT,
AND e OR.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

28

Porta NOT
Porta AND

Porta OR
Entrada
Sada

Figura 40: Portas lgicas, entradas e sadas em um circuito simulado no Logisim

Expresses booleanas so composies dessas operaes bsicas, geralmente escritas


utilizando uma notao mais compacta:

denota NOT
denota OR
ou
denota AND

Parnteses so usados em expresses booleanas da mesma forma que usamos em expresses


aritmticas. Exemplos de expresses booleanas (ou expresses lgicas) so
e
.
Duas operaes booleanas que podem ser derivadas dessas operaes bsicas so NAND e
NOR, definidas por:

NAND
NOR

Ou seja, um NAND um AND seguido de uma negao, assim como um NOR um OR seguido
de uma negao. A importncia das operaes NAND e NOR vem do fato de que sua
construo com transistores mais simples, como veremos a seguir. A Figura 41 mostra os
smbolos utilizados no desenho de circuitos lgicos para as portas NAND e NOR.

Figura 41: Portas NAND e NOR

Transistores so a base para a construo de circuitos compactos e rpidos. Por um lado, a


tecnologia de 2008 permite colocar 800 milhes de transistores em um chip de 244 mm2, e por
outro, o tempo de reao de um desses transistores a mudanas em suas entradas muito
pequeno. Transistores podem ser e so utilizados para amplificar sinais mas, em circuitos

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

29

digitais, funcionam essencialmente como interruptores, trabalhando ora como condutores


perfeitos, ora como isolantes perfeitos.

Voltagem
de Controle

Voltagem
naEntrada

Voltagem
na Sada
Figura 42: Um transistor

Um transistor tem 3 pinos: um controle, uma entrada e uma sada. Em circuitos digitais o seu
funcionamento se d somente nas seguintes situaes:

quando a voltagem aplicada ao controle alta (para algumas tecnologias, 5 V), o


transistor um condutor perfeito, e as voltagens na entrada e na sada so
necessariamente iguais;
quando a voltagem aplicada ao controle baixa (0 V, digamos), o transistor um
isolante perfeito, e as voltagens na entrada e na sada podem diferir.

Vejamos inicialmente como uma porta NOT implementada com a utilizao de um transistor.
Suponhamos que estamos representando o smbolo 0 por uma voltagem baixa e o smbolo 1
por uma voltagem alta. Como mostrado na Figura 43, uma fonte de voltagem alta ligada
entrada do transistor, atravs de uma resistncia, enquanto a sada do transistor ligada um
ponto de terra. A varivel que desejamos negar, , ligada ao controle do transistor. O
resultado do circuito, , obtido no ponto entre a resistncia e a entrada do transistor.

Fonte V= 5
(voltagem alta)

a
1

a
0

Terra V= 0
(voltagem baixa)

Figura 43: Uma porta NOT invertendo a = 0. Como a = 0, o transistor funciona como isolante perfeito

Quando
, a voltagem aplicada ao controle do transistor baixa e ele funciona como
isolante perfeito, e obtemos
.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

30

Fonte V= 5
(voltagem alta)

a
0

a
1

Terra V= 0
(voltagem baixa)
Figura 44: Porta NOT invertendo a = 1. O transistor funciona como condutor perfeito

Quando
, o transistor funciona como condutor perfeito, e obtemos
contato com o ponto de terra estabelecido.

, pois o

Fonte

0 (a + b)
a
1

b
0
Terra
Figura 45: Uma porta NOR com transistores

Uma porta NOR construda com o arranjo de transistores mostrado na Figura 45; no difcil
ver que o ponto
s ter o valor 1 (voltagem alta) quando os dois transistores do
arranjo estiverem funcionando como isolantes, o que s ocorre quando
e
.
Fonte

1 (a.b)
a
1

b
0
Terra
Figura 46: Uma porta NAND implantada com transistores

Uma porta NAND construda de forma similar, mas com os transistores ligados em srie,
como mostra a Figura 46. Aqui a sada
s ser igual a zero quando tivermos
e
, valores que fazem com que a sada esteja conectada ao ponto de terra.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

31

Fonte

Fonte

a.b
0
a
1

Terra

b
0

NAND

NOT

Figura 47: Porta AND com 3 transistores

Para obter uma porta AND basta inverter a sada de uma porta NAND, como mostrado na
Figura 47. Uma porta OR pode tambm ser obtida conectando a sada de uma porta NOR com
a entrada de uma porta NOT.
2.2.3

Introduo ao Logisim

O Logisim um simulador de circuitos lgicos que voc deve baixar pela Internet, no endereo
http://ozark.hendrix.edu/~burch/logisim/ . um simulador com objetivos didticos, que
atende muito bem s nossas necessidades. Este texto segue o tutorial presente no help do
sistema.
Ao iniciar o Logisim voc ver uma tela como a mostrada na Figura 48, talvez diferindo em
alguns detalhes. Ali podemos ver uma barra de menu, uma barra de ferramentas, um painel de
explorao e um painel para o desenho efetivo de circuitos.

Figura 48: Tela inicial do Logisim

Para o nosso primeiro circuito, vamos comear colocando duas portas AND, clicando sobre o
smbolo correspondente na barra de ferramentas, e posicionando as portas na rea de
Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

32

desenho, como mostrado na Figura 49. Repare na tabela de atributos, que exibe e permite a
edio de dados relativos ao elemento selecionado no caso, a porta AND inferior.

Figura 49: Duas portas AND

Depois, usando ainda a barra de ferramentas, vamos colocar uma porta OR e duas NOT,
posicionando-as conforme a Figura 50.

Figura 50: Acrescentando portas NOT e OR

O prximo passo a colocao de entradas e sadas, que so colocadas usando os cones em


destaque na Figura 51.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

33

Figura 51: Acrescentando entradas e sadas

Para colocar fios ligando entradas, portas e sadas, utilize a ferramenta de seleo em
destaque na Figura 52. Fios sempre seguem caminhos horizontais e verticais (chamado
caminho Manhattan), e nunca em diagonal.

Figura 52: Acrescentando o cabeamento

Uma operao lgica importante o Ou Exclusivo, escrito frequentemente como XOR


(exclusive or). Se a e b so variveis booleanas (isto , variveis cujos nicos valores possveis
so Verdadeiro e Falso, ou 0 e 1), a XOR b s tem o valor 1 (Verdadeiro) quando uma e
somente uma das variveis a e b tem o valor 1. O Ou Exclusivo no uma operao primitiva
da lgebra booleana, pois pode ser obtido atravs da expresso a XOR b = ab + ab. Termine
agora o cabeamento para obter o circuito da Figura 53 que implementa o Ou Exclusivo.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

34

Figura 53: Circuito OU Exclusivo

Seu circuito ficar mais fcil de ser compreendido se voc acrescentar textos, usando a
ferramenta A em destaque na Figura 54. Voc pode alterar as caractersticas da fonte
(tamanho, negrito ou itlico, etc.) editando os atributos do texto selecionado.

Figura 54: Acrescentando textos a um circuito

Textos podem ser colocados em qualque posio na rea de desenho, mas muitas vezes
melhor coloc-los como "labels" de elementos de circuito, como entradas, portas lgicas e
sadas. O label acompanha o elemento quando este movido para outra posio. Para isto,
selecione o elemento, e preencha o campo Label na tabela de atributos, como mostrado na
Figura 54.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

35

Figura 55: Ferramenta de toque para simulao de um circuito

Para testar o seu circuito, use a ferramenta de toque, em destaque na Figura 55. Utilize-a
sobre as entradas do circuito para alterar o seu valor. Explore todas as combinaes possveis
de valores para a e b, verificando a sada para completar a Tabela 10: Complete com os valores
produzidos pelo seu circuito XOR
Tabela 10: Complete com os valores produzidos pelo seu circuito XOR

a
0
0
1
1

b
0
1
0
1

a XOR b

Circuitos podem ser salvos em arquivos para uso posterior. Para salvar o seu circuito, use a
opo File/Save do menu do Logisim, escolha um nome para o arquivo e um diretrio, e salveo. Para voltar a trabalhar com o arquivo, use File/Open.
Para introduzir elementos de circuito com outras orientaes, clique sobre a ferramenta
desejada, e depois altere o campo Facing na tabela de atributos, conforme mostrado na figura
abaixo.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

36

Figura 56: Mudando a orientao de uma porta lgica

Com isso ns esperamos que voc tenha adquirido os elementos bsicos para o uso do
Logisim. Voc pode descobrir muito mais lendo a ajuda ou explorando diretamente a
ferramenta.
2.2.4

Aritmtica com operaes lgicas

Figura 57: Circuito correspondente expresso a'(ca)'(b'+c)

Ns vimos como circuitos lgicos implementam expresses lgicas, com um mapeamento


direto. Por exemplo, a Figura 57 mostra um circuito que corresponde expresso
. No difcil acreditar que conseguimos obter circuitos para qualquer expresso lgica. Mas
podemos fazer circuitos lgicos que fazem contas? Ora, todos sabemos que computadores
fazem contas, e sabemos portanto que a resposta afirmativa. Resta saber como!
2.2.4.1 Soma de 2 inteiros de 1 bit
Vamos comear por um problema bem simples: encontrar um circuito lgico que faa a soma
de dois inteiros representados como binrios sem sinal de 1 bit cada um. Na base 10, o
resultado pode ser 0, 1 ou 2. Portanto o resultado, tambm codificado como binrio sem sinal,
pode ser 00, 01 ou 10. Ou seja, so necessrios 2 bits para representar o resultado da soma de
duas variveis de 1 bit.
importante entender que somar significa obter a representao como um binrio sem sinal
da soma das entradas , entendidas tambm como binrios sem sinal. (Na verdade, calcular
uma funo qualquer significa transformar a representao de seus argumentos na
Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

37

representao do valor da funo). A Figura 58 mostra as entradas e sadas do circuito que


pretendemos construir.
Entradas
1 bit cada

Circuito Somador
1 bit
Sadas

s1 s0

Notao comum para


conjuntos de bits:
0 o ndice do bit
menos significativo

Figura 58: Entradas e sadas de um somador de 1 bit

Para especificar exatamente o que desejamos deste circuito, vamos utilizar uma tabela da
verdade. Uma tabela da verdade apresenta o valor de uma ou mais funes lgicas as sadas
do circuito correspondendo a cada valor possvel das variveis de entrada. A Figura 59
mostra a tabela da verdade para a soma de duas variveis de 1 bit.

Entradas

Todos os
valores
possveis para
as entradas

Sadas:
2 funes
lgicas das
mesmas
variveis

Resultados da
soma em
binrio sem
sinal

Figura 59: Tabela da Verdade para soma de duas variveis de 1 bit

Nessa tabela ns temos:

duas variveis de entrada, e ;


duas funes de sada, e ; cada funo corresponde a um dgito binrio do
resultado;
a cada linha da tabela corresponde uma combinao das variveis de entrada e o valor
correspondente das funes de sada. Como so duas variveis, temos
linhas
na tabela.

Tabelas da verdade constituem um mecanismo geral para a especificao de funes lgicas.


Elas especificam as sadas para cada combinao possvel das variveis de entrada. Ns j
vimos tabelas da verdade quando introduzimos as funes NOT, AND e OR (Tabela 9). Tabelas
da verdade podem ser usadas para verificar a equivalncia de expresses booleanas: se duas
expresses levam a uma mesma tabela da verdade, elas so equivalentes. Como exerccio,
verifique se a expresso
equivalente expresso
construindo uma tabela da verdade com todos os valores possveis de
para cada linha o valor de cada expresso.
Introduo Organizao e Programao de Computadores

e , e calculando

IOPC 2010_2-3

Organizao de Computadores

38

Dada uma expresso lgica, ns podemos construir sua tabela da verdade efetuando as
operaes da expresso. Mas para obter um circuito lgico para uma das funes de sada a
partir de uma tabela da verdade preciso:

conseguir uma expresso lgica equivalente tabela da verdade, e


construir o circuito equivalente expresso lgica.

Uma expresso lgica e uma funo definida por uma tabela da verdade so equivalentes
quando para qualquer combinao de valores das variveis de entrada, os valores da funo e
os valores da expresso so iguais.
Tabela 11: Tabela da verdade para a funo f(x,y)

Por exemplo, a funo


.

f(x,y)

0
0
1
1

0
1
0
1

1
0
0
1

definida pela Tabela 11 equivalente expresso

Um mtodo genrico para se obter uma expresso lgica para uma funo definida por uma
tabela da verdade consiste em fazer um OR de termos que s tm o valor 1 para cada
combinao das variveis de entrada para a qual o valor da funo igual a 1.
x

f(x,y)

xy + xy

Figura 60: Cobertura dos 1s de uma funo booleana

Na Figura 60,
quando
e

somente na primeira linha, quando


. Ns temos:

se e somente se
se e somente se

e
e

, e na ltima linha,

;
.

Portanto,
cobre exatamente os 1s da tabela, e uma expresso lgica
equivalente funo desejada.
s0 = ab + ab

s1 = ab

Figura 61: Expresses lgicas para um somador de duas variveis de 1 bit

Retornando ao problema do somador de 1 bit, temos duas funes para as quais queremos
encontrar expresses lgicas equivalentes. Na Figura 61 vemos que, para a funo , temos
apenas o 1 da ltima linha a cobrir, o que feito pelo termo , e para a funo , temos um
Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

39

1 na segunda linha, coberto pelo termo


, e outro 1 na terceira linha, coberto pelo termo
. Ou seja, as expresses lgicas que desejamos so
e
. A Figura 62
mostra um circuito que implementa essas expresses lgicas. Este circuito conhecido como
circuito meia-soma, por contraste com o circuito soma-completa que veremos a seguir.

ab
ab

ab
Figura 62: Circuito lgico para soma binria de 1 bit, ou circuito meia-soma

Temos aqui um resultado importantssimo: ns fomos capazes de construir um circuito lgico


com duas entradas de 1 bit representando binrios sem sinal, e que produz em sua sada dois
bits representando a soma das entradas, tambm codificado como um binrio sem sinal. Ou
seja, conseguimos fazer contas com as funes lgicas NOT, AND e OR.
2.2.4.2 Soma de binrios com vrios bits
Tudo bem, conseguimos fazer um circuito que realiza a soma de duas variveis de 1 bit. Mas
isso muito pouco. Para fazer qualquer coisa mais sria, precisamos ser capazes de somar
variveis de, digamos, 32 bits, como so representados inteiros na maior parte dos
computadores atuais.
Em princpio ns poderamos construir uma tabela da verdade com as entradas e sadas, e
depois inferir expresses lgicas para as sadas usando o mtodo de cobertura dos 1s. Essa
tabela teria 64 bits de entrada, correspondendo s duas variveis a serem somadas, e 33 bits
de sada, pois a soma de duas variveis de 32 bits pode ter 33 bits. O problema que essa
tabela teria
= 18.446.744.073.709.551.616 linhas! Ou seja, mesmo se teoricamente
conseguiramos construir o somador de 32 bits pelo mtodo de cobertura dos 1s, na prtica
isso absolutamente invivel.
Temos portanto que adotar outro enfoque. Primeiramente vamos examinar como ns,
humanos, fazemos uma soma em binrio. Depois, vamos construir um somador de forma
modular, explorando regularidades no processo de soma.
Uma soma de nmeros binrios similar soma decimal que aprendemos na escola primria.
Para fazer uma soma na base 10 ns somamos algarismo por algarismo, da direita (menos
significativos) para a esquerda (mais significativos). Quando a soma de dois algarismos excede
9, colocamos como resultado daquela coluna somente o dgito mais significativo, e
acrescentamos 1 (o vai-um) na soma da coluna seguinte (Figura 63).

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

40

Vai-um
a
b
a+b

1
2
4
7

1
7 7 6
7 9 1
5 6 7

Figura 63: Soma em decimal

Para somar dois nmeros binrios o procedimento anlogo. Somamos bit a bit, da direita
para a esquerda e, quando a soma de uma coluna excede 1, colocamos como resultado da
coluna somente o bit mais significativo de sua soma, e temos um vai-um para a coluna
seguinte. A Figura 64 mostra o processo do clculo de 1011101+1001110.
Vai-Um
1

Parcelas

Soma

Figura 64: Exemplo de soma de binrios

Ns vamos usar essa aritmtica para construir um circuito somador de vrios bits. A idia
construir um mdulo que faa a operao de uma das colunas da soma. O somador ter tantos
deste mdulo quantas forem as colunas, ou seja, quantos forem os bits das parcelas.

vai-um
soma

SC

vem-um

a
b

Figura 65: Entradas e sadas de um circuito de soma completa

Este mdulo, esquematizado na Figura 65, ter trs entradas:

os dois bits de uma coluna das parcelas, e


uma entrada que vamos chamar de vem-um, que vamos ligar sada vai-um da
coluna direita,

As sadas do mdulo so duas:

um bit de resultado
um bit de vai-um, que ser ligado entrada vem-um da coluna esquerda.

Um circuito que implemente esse mdulo conhecido como circuito soma-completa.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

41

Circuito
Soma-Completa

vem-um do
bit menos
significativo
sempre
zero

Igual a 1
quando a
soma tiver
5 bits

Figura 66: Arranjo em cascata de mdulos para um somador de 4 bits

A Figura 66 mostra um arranjo em cascata de circuitos de soma completa capaz de somar


variveis de 4 bits. O mdulo SC mais direita faz a soma dos bits menos significativos, e .
Sua entrada vem-um recebe o valor constante 0. Ele produz um bit de resultado, , e o vaium da coluna, que conectado entrada vem-um do segundo SC da direita para a esquerda.
Este segundo SC faz a soma de , e de sua entrada vem-um que, como dissemos, o vaium do primeiro SC. E esse arranjo se repete, aqui para os 4 bits das parcelas, mas poderia se
repetir por 32, ou por 64, ou por 128 vezes. Em um somador de bits, o circuito de soma
completa do bit mais significativo produz um vai-um que indica que a soma das parcelas s
pode ser representada com
bits. Essa situao designada por estouro, ou mais
comumente, pelo termo em ingls overflow.
soma = abv + abv + abv + abv
a

vem-um

soma

vai-um

vai-um = abv + abv + abv + abv


Figura 67: Tabela da verdade para um circuito de soma completa

A Figura 67 mostra a tabela da verdade para um circuito de soma completa, e as expresses


encontradas pelo mtodo de cobertura dos 1s para as sadas soma e vai-um. A varivel
designa aqui a entrada vem-um.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

42

Figura 68: Circuito Soma-Completa

A Figura 68 mostra um circuito de soma completa. Repare que a sada vai-um dada pela
expresso simplificada
onde designa a sada Vai-um, e que equivalente expresso
encontrada pelo mtodo de cobertura de 1s. Para verificar essa equivalncia voc pode
construir uma tabela da verdade para as duas expresses. A simplificao de expresses
lgicas um assunto de extrema importncia, mas que foge do escopo deste texto.
2.2.5 Sntese de Circuitos Combinatrios
possvel utilizar o Logisim para construir automaticamente um circuito combinatrio a partir
de sua tabela da verdade. Vamos fazer isto para um circuito que tem as variveis a2, a1 e a0
como entradas, e b2, b1 e b0 como sadas. Aqui tambm vamos usar operaes lgicas para
implementar operaes aritmticas - no caso, somar 1 a um dado valor binrio.
Mais precisamente, o valor expresso por b2b1b0 interpretado como binrio sem sinal deve ser
igual ao valor expresso por a2a1a0 + 1, tambm interpretado como binrio sem sinal. Por
exemplo, para os valores de entrada a2 = 1, a1 = 0 e a0 = 0 (ou seja, o valor expresso pela
entrada 1002 = 410), devemos ter b2 = 1, b1 = 0 e b0 = 1 (com o valor expresso pela sada
dado por 1012 = 510).
Temos que nos preocupar com o caso onde a2a1a0 = 111, pois 111+1 = 1000, com quatro bits,
um a mais do que dispomos. Vamos adotar como conveno que, quando a2a1a0 = 111, a
sada deve ser 000. Este circuito corresponde tabela da verdade na Figura 69. Ns veremos a
seguir como fcil obter um circuito para esta ou para qualquer outra tabela da verdade de
tamanho razovel utilizando o Logisim.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

a2
0
0
0
0
1
1
1
1

43

a1
0
0
1
1
0
0
1
1

a0
0
1
0
1
0
1
0
1

b2
0
0
0
1
1
1
1
0

b1
0
1
1
0
0
1
1
0

b0
1
0
1
0
1
0
1
0

Figura 69: Tabela da verdade para o circuito SomaUm

Janela de Anlise Combinatria. O primeiro passo abrir a janela de anlise combinatria do


Logisim, o que feito conforme ilustrado na Figura 70.

Figura 70: Abrindo a janela de anlise combinatria do Logisim

No passo seguinte ns informamos ao Logisim os nomes das variveis de entrada. Devemos


clicar sobre a aba Inputs (se no estiver j selecionada) e, para cada varivel de entrada, digitar
o seu nome e clicar sobre o boto Add, conforme a Figura 71.

Figura 71: Variveis de entrada de uma tabela da verdade no Logisim

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

44

Entre com as variveis na ordem (da esquerda para a direita) em que voc deseja que elas
apaream na tabela da verdade. No caso, primeiro a2, depois a1 e depois a0.
Para as variveis de sada o procedimento similar. Selecione a aba Outputs, e entre um a um
com os nomes das variveis de sada, na ordem em que voc deseja que apaream na tabela
da verdade. No caso, primeiro b2, depois b1 e depois b0.

Figura 72: Nomeando variveis de sada em uma tabela da verdade no Logisim

Agora preciso entrar com os valores da tabela da verdade. Clique sobre a aba Table, e voc
ver uma tela como a da Figura 73.

Figura 73: Entrando com os valores da tabela da verdade

Depois, entre com os valores apropriados, clicando uma ou mais vezes sobre cada um dos x na
tabela, at obter o valor desejado. Se passar do ponto, clique novamente. Faa isto at chegar
tabela da Figura 74, onde voc pode reparar que em cada linha, b2b1b0 = a2a1a0+1, exceto
na ltima, onde seguimos a conveno j mencionada.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

45

Figura 74: Tabela da verdade pronta

Agora s clicar sobre Build Circuit, e o circuito SomaUm est pronto! Confira com a tela da
Figura 75 o circuito que voc construiu.

Figura 75: Circuito SomaUm obtido automaticamente

Teste o seu circuito com os valores binrios correspondentes aos valores decimais 2, 5 e 7,
verificando se as sadas interpretadas como binrios sem sinal correspondem a 3(= 2+1),
6(=5+1) e 0(pois 710 = 1112).
importante voc reparar que o Logisim criou o circuito SomaUm como um sub-circuito, o que
indicado no painel de navegao veja a seta na Figura 75. Ns vamos agora utilizar o
SomaUm como um componente para construir o circuito SomaTrs, o que pode ser feito
ligando trs circuitos SomaUm em cascata.
Para isto clique com o boto direito do mouse sobre o sub-circuito main, e escolha View
Circuit. Voc ver um circuito vazio. Agora clique com o boto esquerdo do mouse sobre o
sub-circuito SomaUm, e coloque no painel de desenho 3 bloquinhos conforme a figura abaixo.
Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

46

O bloquinho o circuito SomaUm representado aqui como um mdulo sem detalhes,


somente com as entradas e sadas. Passe com o mouse sobre essas entradas e sadas; o
Logisim indica o nome de cada uma delas.
Como voc pode ver, subimos de nvel. Os detalhes do circuito SomaUm podem ser esquecidos
o que nos interessa agora somente sua funcionalidade de somar 1 sua entrada.

Figura 76: O circuito SomaTrs

Complete agora o seu circuito principal, acrescentando entradas, sadas e cabeamento


conforme a figura acima. A disposio de entradas e sadas foi escolhida para facilitar sua
leitura como um binrio sem sinal. Para obter entradas voltadas para baixo, clique sobre a
ferramenta de entradas e, no painel de parmetros, no canto inferior esquerdo da tela do
Logisim, e escolha South como orientao. Para obter sadas com o ponto de conexo encima,
clique sobre a ferramenta de sadas, e escolha a orientao North.
Teste o seu circuito e veja se a sada corresponde sempre entrada mais 3. Lembre-se da
conveno que adotamos de ter 000 como o sucessor de 111.
Como um exemplo mais detalhado, vamos o usar o Logisim para construir um display
hexadecimal, isto , um circuito que acende os filamentos correspondentes ao smbolo
hexadecimal codificado em seus 4 bits de entrada em uma lmpada de 7 segmentos. Este
um dispositivo simples e eficaz para a visualizao de algarismos decimais e de algumas letras,
que voc certamente j viu em elevadores ou sintonizadores de TV a cabo.

Figura 77: Uma lmpada de 7 segmentos com todos os filamentos acesos

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

47

O Logisim oferece este componente, na biblioteca Input/Output. Cada um dos pinos acente
um dos filamentos, com exceo de um pino que acende um ponto decimal, que no vamos
usar aqui.

Center

Upper Right

Lower Left
Lower Right

Figura 78: Nomes dos pinos em uma lmpada de 7 segmentos

A Figura 78 mostra os labels dos pinos de entrada de uma lmpada de 7 segmentos, e na


Figura 79 ns vemos o arranjo de entradas e sadas do circuito que iremos sintetizar.

4 bits de
entrada

Circuito que
queremos

Figura 79: Arranjo de entradas e sadas de circuito de controle de um display hexadecimal

Para isso, abrimos a janela Combinational Analysis do Logisim, e construmos uma tabela da
verdade com 4 entradas, a3, a2, a1 e a0, e com 7 sadas, UL, U, C, UR, LL, P, L e LR. Para cada
linha colocamos 1 nas sadas correspondentes aos filamentos que, acesos, compem o dgito
hexadecimal formado pelos bits de entrada. A tabela final est mostrada na Figura 80.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

48

Figura 80: A tabela da verdade completa para o display hexadecimal, com destaque para a determinao das
sadas para formar um F

Feito isso, basta apertar Build Circuit para obter o circuito da Figura 81. Parece complicado?
Pode ser, mas isso no um problema. O circuito foi construdo automaticamente, a partir de
uma tabela da verdade, usando algoritmos do Logisim que so melhorias do mtodo que
vimos para obteno de somas cannicas. Isso nos garante a sua correo. E ele pode ser
usado como um mdulo, esquecendo completamente seus detalhes, como fizemos na Figura
79.

Figura 81: Circuito gerado automaticamente pelo Logisim para o controlador de display hexadecimal

2.2.6

Comparao de binrios sem sinal

b
Comparador

a<b

a=b

a>b

Figura 82: Entradas e sadas de um circuito comparador

Vimos na seo 2.2.4 que circuitos lgicos podem realizar operaes aritmticas. Vamos agora
atacar o problema de construir circuitos lgicos que permitam comparar duas variveis e
Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

49

de, digamos, 32 bits cada uma. A sada do circuito deve indicar se


como mostrado na Figura 82.

ou

Aqui tambm temos problemas com o uso do mtodo de cobertura de 1s na tabela da


verdade, que teria as mesmas
linhas do somador de 32 bits. Vamos aplicar o mesmo
enfoque que usamos na soma: verificar como fazemos a comparao, e procurar resolver o
problema por etapas que seriam feitas por mdulos menores.

aMaior
abIguais
bMaior

aMaior
abIguais
bMaior

aMaior
abIguais
bMaior

a
b

1
1

1
1

1
1

1
0

1
1

0
1

0
1

0
0

0
1
0

0
1
0

0
1
0

0
1
0

1
0
0

1
0
0

1
0
0

1
0
0

1
0
0

a
b

0
1

1
1

1
1

1
0

1
1

0
1

0
1

0
0

0
1
0

0
0
1

0
0
1

0
0
1

0
0
1

0
0
1

0
0
1

0
0
1

0
0
1

a
b

1
1

1
1

1
1

0
0

1
1

0
0

1
1

0
0

0
1
0

0
1
0

0
1
0

0
1
0

0
1
0

0
1
0

0
1
0

0
1
0

0
1
0

Figura 83: Casos de comparao entre as entradas a e b.

fcil ver que, ao comparar dois binrios de mesmo tamanho, sem sinal, devemos comparar
bit a bit, comeando com o bit mais significativo. Na primeira diferena, j podemos concluir
que a parcela com o bit igual a 1 definitivamente a maior, e os bits restantes, que so menos
significativos, no interessam para o resultado final. A Figura 83 mostra trs casos de
comparao de entradas e , cada uma com 8 bits. No primeiro caso as entradas diferem no
quarto bit mais significativo, e
. No segundo caso as entradas j diferem no primeiro bit
mais significativo, e
. No terceiro caso as entradas so iguais.
Para construir um circuito que faa a comparao de binrios sem sinal ns precisamos de um
comparador de 1 bit que leve em considerao a possibilidade do resultado j ter sido
estabelecido por algum bit mais significativo.
Bit corrente

a
Amaior

b
aMaior
bMaior

Mdulo
Comparador
de 1 bit

Bmaior
ABiguais

abIguais

Vm do comparador
esquerda

Vo para o
comparador direita

Figura 84: Entradas e sadas para um mdulo comparador de 1 bit

Vemos na Figura 84 um esquema de entradas e sadas para o mdulo comparador de 1 bit. As


entradas a e b vm do bit em questo das variveis que estamos comparando. Da comparao
Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

50

j feita com bits mais significativos que o bit em questo vm as entradas aMaior, bMaior e
abIguais. A Figura 85 mostra o arranjo de mdulos que compem um comparador de 4 bits.

Entrada b

Entrada a

Para o bit mais significativo,


aMaior = bMaior = 0, e
abIguais = 1
Figura 85: Arranjo de mdulos para um comparador de 4 bits

Temos um mdulo comparador para cada bit das variveis de entrada. Cada mdulo
comparador tem cinco entradas:

Duas so os bits das entradas da coluna correspondente ao mdulo;


As trs outras so designadas por aMaior, bMaior e abIguais e, exceto para o mdulo
mais esquerda, so produzidas pelo mdulo comparador esquerda do mdulo em
questo. Elas tm o resultado da comparao j realizada com os bits mais
significativos e portanto, uma e somente uma dessas entradas poder ter o valor 1.
Para o mdulo mais esquerda, que corresponde ao bit mais significativo, abIguais
tem o valor 1.

A Figura 86 mostra as primeiras linhas de uma tabela da verdade para o mdulo comparador
de 1 bit; a tabela completa tem
linhas. A coluna aMaior uma entrada desse mdulo,
enquanto a coluna Amaior uma sada. A mesma conveno usada para bMaior, Bmaior,
abIguais e ABiguais. Combinaes onde mais de uma dentre as variveis aMaior, bMaior e
abIguais tm o valor 1 ou em que todas as trs so iguais a 0 nunca devem ocorrer, e o
smbolo usado na tabela para indicar que os valores das sadas no tm interesse nesses
casos. O Logisim tira proveito disso para obter circuitos mais simples.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

51

Estas sadas
vo para a
coluna direita

Estas
entradas
vm da
coluna
esquerda

x usado quando a
combinao de entradas
nunca ocorre o Logisim
simplifica o circuito
Figura 86: Tabela da verdade para um comparador de 1 bit

A Figura 87 mostra o circuito comparador de 1 bit obtido dessa tabela da verdade.

Figura 87: Circuito comparador de 1 bit

2.2.7

Multiplexadores e Demultiplexadores

Circuitos lgicos so tambm utilizados para conduzir fluxos de dados:

Um multiplexador dirige uma nica entre vrias entradas de dados para um destino; a
entrada escolhida designada por um endereo;

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

52

Um demultiplexador dirige uma entrada de dados para um dentre vrios destinos; o


destino escolhido designado por um endereo.
a, de address,
determina
qual entrada
ser
encaminhada
para a sada
Out

out = In0
quando a=0

out = In1
quando a=1

Figura 88: Tabela da verdade para um multiplexador de 1 bit

A Figura 88 mostra uma tabela da verdade para um multiplexador de 1 bit. Esse circuito tem
trs entradas: In0 e In1, que so as variveis fonte de informao, e o endereo a, que decide
qual dentre In0 e In1 ser conectada sada out.
out0 = In
quando a=0
a (address)
indica para
qual sada a
entrada In
ser copiada
out1 = In
quando a=1

Figura 89: Tabela da verdade para um demultiplexador de 1 bit

Na Figura 89 ns vemos a tabela da verdade para um demultiplexador de 1 bit. Esse circuito


tem as entradas a e In. A entrada a um endereo de 1 bit e que designa qual das sadas out0
ou out1 ser conectada entrada fonte de informao In.

Figura 90: Circuito multiplexador de 1 bit

Multiplexadores de 1 bit tambm podem ser usados como mdulos para a construo de
multiplexadores de mais bits, com o arranjo mostrado na Figura 91.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

53

O binrio a1a0
designa qual
entrada fica
ligada sada

Figura 91: Um multiplexador de 2 bits obtido usando multiplexadores de 1 bit

A Figura 92 mostra o circuito demultiplexador de 1 bit obtido a partir da tabela da verdade da


Figura 89.

Figura 92: Circuito demultiplexador de 1 bit

Demultiplexadores com uma largura de entrada (nmero de bits) maior tambm podem ser
obtidos com arranjos hierrquicos similares, como mostra a Figura 93.

DMX
1 bit
DMX
1 bit
DMX
1 bit
Figura 93: Circuito demultiplexador de 2 bits, obtido a partir de demultiplexadores de 1 bit

Como concluses de nosso estudo de circuitos combinatrios ns temos:

Operaes lgicas podem ser usadas para realizar operaes aritmticas;


Circuitos combinatrios podem ser construdos a partir de tabelas da verdade;
Circuitos combinatrios tambm podem ser construdos como montagens de mdulos
mais simples, como somadores ou comparadores de bits construdos a partir de
somadores ou comparadores de 1 bit;
O fluxo de informaes em um circuito pode ser conduzido por multiplexadores ou
demultiplexadores.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

54

2.3 Circuitos Sequenciais


Circuitos seqenciais diferem dos circuitos combinatrios por serem capazes de armazenar
dados. Em um dado instante suas sadas no dependem apenas dos valores correntes de suas
entradas, como nos circuitos combinatrios, mas so tambm funes de valores
armazenados.
2.3.1

Flip-flops e Registradores
Funciona como
um obturador de
mquina
fotogrfica

Bit
Armazenado

Complemento
do Bit
Armazenado

A entrada D
fotografada no
instante em que o clock
passa de 0 para 1
Pino Auxiliar:
Impe 1

Pino Auxiliar:
Impe 0

Figura 94: Um flip-flop tipo D

O circuito seqencial mais bsico conhecido pelo nome em ingls de flip-flop. Como
podamos esperar, um flip-flop capaz de armazenar um nico bit. Existem vrios tipos de flipflop, mas aqui ns s veremos flip-flops ditos do tipo D. A Figura 94 mostra um flip-flop tipo D
disponvel no Logisim, e que possui 5 pinos:

Pino D: onde fica a informao o Dado que pode vir a ser armazenada no flipflop;
Pino Clock: um pino que funciona como um obturador de uma mquina fotogrfica.
No exato instante em que o sinal aplicado ao Clock passa de 0 para 1, o flip-flop passa
a armazenar o valor corrente do pino Input. O nome clock vem do fato deste sinal
frequentemente se originar de uma fonte de tempo, como veremos mais tarde. Click
seria um nome mais adequado para a analogia com a mquina fotogrfica.
Pino Q: uma sada que tem o valor armazenado no flip-flop;
Pino Q: uma sada que tem o complemento do valor armazenado no flip-flop;
Pinos Set e Reset: so entradas auxiliares que facilitam a imposio de um valor para o
flip-flop. Essas entradas so normalmente usadas para inicializao ou re-inicializao
do flip-flop.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

55

Clock

D
2

Q
0

-1
1

10

11

12

13

Tempo
Figura 95: Carta de tempo para um flip-flop tipo D. As setas destacam os instantes de subida do clock, quando a
entrada D copiada pelo flip-flop.

A Figura 95 mostra um grfico uma carta de tempo que ilustra um exemplo de evoluo
temporal de um flip-flop tipo D, onde:

no instante 1 as entradas D e Clock valem 0, assim como a sada Q;


nos instantes 2, 3 e 4 respectivamente a entrada D muda de 0 para 1, de 1 para 0 e de
0 para 1 novamente, sem que isso afete a sada Q, pois a entrada Clock permanece em
0 durante esse intervalo;
no instante 5 a entrada Clock sobe, mudando de 0 para 1. a este sinal que o flip-flop
copia (fotografa) a entrada D. Com isso o bit armazenado muda tambm de 0 para 1;
no instante 6 a entrada Clock desce, mas isso no afeta o estado do flip-flop;
nos instantes 7, 8 e 9 a entrada D oscila novamente, sem afetar o estado do flip-flop;
no instante 10 o sinal do Clock sobe, e a sada Q passa para 0, copiando o valor de D
nesse instante;

E por a vai.
Clock
nico para
os 4 FFs

Sadas

Entradas
Figura 96: Um registrador de 4 bits formado por flip-flops tipo D

Flip-flops podem ser agrupados formando registradores. A Figura 96 mostra um registrador de


4 bits composto por flip-flops do tipo D, onde vemos que:

um mesmo sinal de clock comanda os 4 flip-flops;


na subida deste sinal, isto , quando o clock passa de 0 para 1, as quatro entradas D
so copiadas para os flip-flops;
uma entrada Reset coloca 0 em todos os flip-flops ao receber um sinal 1.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

56

O Logisim oferece uma srie de circuitos j prontos, que encontram-se armazenados em


bibliotecas, e que podem ser utilizados como peas para a montagem de circuitos maiores, da
mesma forma como j usamos portas lgicas. Flip-flops tipo D, outros tipos de flip-flop,
registradores e vrios outros componentes se encontram na biblioteca Memory.

Valor
armazenado,
em
hexadecimal

Registradores
Largura de
dados

Figura 97: Um registrador da biblioteca Memory do Logisim com largura de 8 bits

Registradores da biblioteca Memory do Logisim so sempre apresentados como um nico


bloco que se assemelha a um flip-flop, mas que capaz de armazenar um nmero de bits
escolha do usurio. Um cabo conectado entrada D de um registrador de 4 bits deve tambm
ter uma largura de 4 bits.

Figura 98: Dois circuitos equivalentes. No circuito de cima, fios e registradores tm 1 bit de largura; no de baixo, 4
bits

Na Figura 98 ns vemos dois circuitos equivalentes, cada um com dois registradores de 4 bits
conectados. O circuito de cima utiliza somente elementos de largura de 1 bit, com os quais j
estamos familiarizados. O de baixo utiliza entradas, sadas, registradores e cabos de 4 bits de
largura. Seu desenho por isso mesmo muito mais simples e, portanto, de mais fcil
compreenso. A largura de bits de componentes como registradores, entradas e sadas
controlada pelo usurio, usando o campo data width no painel de atributos, como na Figura
Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

57

97. O Logisim facilita a nossa vida dando a cabos a largura de bits dos componentes aos quais o
cabo se conecta, e alertando o usurio nos casos de incompatibilidade.

5 bits
2 bits

8 bits

1 bit
Figura 99: Uma bifurcao de um cabo de 8 bits em um de 5 bits, outro de 2 e um terceiro de 1 bit de largura. O
retngulo esquerda uma ampliao do painel de atributos da bifurcao

O Logisim oferece ainda bifurcaes (splitters) que permitem dirigir os bits de um cabo com
largura maior para outros de largura menor, como mostrado na Figura 99.
2.3.2

Barramentos e Controle de Fluxo de Dados


Toda sada ligada ao
barramento passa por um
Controlled Buffer

A todo instante, no
mximo um controlled
buffer pode ter o controle
do barramento
O dado no barramento
igual sada com o
controlled buffer ligado
Figura 100: Um barramento conectando uma entrada de 8 bits e trs registradores

Nos circuitos que vimos at agora um cabo s pode ser usado para conectar uma sada de um
componente a uma ou mais entradas de outros componentes. Essa restrio vem por um lado
da falta de sentido lgico nesse tipo de conexo: se uma das sadas tem 0 e outra 1, qual valor
fica no barramento? Por outro lado, vem tambm dos circuitos reais: se uma de duas sadas
conectadas a um cabo tem o valor 0 e outra tem o valor 1, temos uma voltagem alta ligada
diretamente a uma voltagem baixa, ou seja, um curto-circuito.
Um componente especial, o controlled buffer, permite fazer esse tipo de ligao, o que
simplifica muito o desenho de circuitos. Diversas sadas podem ser conectadas a um nico
cabo se essas conexes passarem por um controlled buffer. Este cabo compartilhado recebe o
nome de barramento. Todo controlled buffer tem, como o prprio nome indica, um pino de
controle que abre ou fecha a conexo com o barramento. O projetista de um circuito deve
Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

58

cuidar para que, a qualquer instante, no mximo um dentre todos os controlled buffers ligados
a um mesmo barramento esteja aberto.
Colocar 7 no registrador A
Sinal
In = 7
In->Dbus = 1
A Clk = 1
A Clk = 0
In->Dbus = 0

Comentrio
Coloca 7 na entrada In
A entrada In controla o barramento
O registrador A copia o barramento
Abaixa o clock do registrador A
Libera o barramento

Colocar 3 no registrador B
Sinal
In = 3
In->Dbus = 1
B Clk = 1
B Clk = 0
In->Dbus = 0

Comentrio
Coloca 3 na entrada In
A entrada In controla o barramento
O registrador B copia o barramento
Abaixa o clock do registrador B
Libera o barramento

Copiar no registrador C o contedo de A


Sinal
A->Dbus = 1
C Clk = 1
C Clk = 1
A->Dbus = 0

Comentrio
O registrador A controla o barramento
O registrador C copia o barramento
Abaixa o clock do registrador C
Libera o barramento

Figura 101 : Exemplos de fluxos de dados realizveis pelo circuito da Figura 100

O circuito da Figura 100 permite que um dado na entrada In seja copiado por qualquer dos
registradores A, B ou C, e permite tambm que o valor em qualquer registrador seja copiado
por qualquer um dos outros registradores. Estes fluxos so controlados pelos sinais de clock
dos registradores e de controle dos controlled buffers. Dados so transferidos de um ponto
para outro ligando e desligando esses sinais em uma sequncia apropriada para a
transferncia desejada, como mostram os exemplos na Figura 101.
2.3.3

Memrias

O Logisim oferece memrias RAM (Random Access Memory) e ROM (Read Only Memory)
como componentes de sua biblioteca Memory. Memrias armazenam informaes como
conjuntos de bits chamados palavras. Cada palavra possui um endereo na memria. Uma
memria tem como atributos sua largura de dados, isto , o nmero de bits em cada palavra
da memria, e a largura do endereo. Com bits de endereo uma memria tem no mximo
palavras. No Logisim, a largura de bits do endereo determina tambm o tamanho da
memria, que tem exatamente
palavras.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

59

Entrada e
tambm sada
de dados

Memory
Address
Register

Na subida,
copia D na
posio A

Figura 102: Uma memria RAM do Logisim em um arranjo com registradores e barramento

A Figura 102 mostra um arranjo de uma memria RAM e de registradores em torno de um


barramento. As operaes de leitura e escrita se fazem com uma nica palavra da memria,
determinada pelo valor aplicado entrada A:

para escritas, o sinal RAM Clk funciona como o clock de um registrador: na subida de 0
para 1, o valor presente na entrada D copiado para a posio de memria
endereada pela entrada A, o que, no arranjo da Figura 102, o valor armazenado no
registrador MAR, o Memory Addres Register;
para leituras, o sinal RAM->DBus funciona como um controlled buffer conectado
sada de um registrador: enquando seu valor for 1, a memria coloca no barramento o
contedo da palavra endereada pela entrada A.
Escrever 9 na posio de memria 15 (=ff)
Sinal
Input = 15
In Clk = 1
In Clk = 0
In->Dbus = 1
MAR Clk = 1
MAR Clk = 0
Input = 9
In Clk = 1
In Clk =0
RAM Clk = 1
RAM Clk = 0
In->Dbus = 0

Comentrio
Coloca 15 (00001111) na entrada Input
O registrador In copia a sua entrada
Abaixa o clock do registrador In
O registrador In controla o barramento
O registrador MAR copia a sua entrada; a entrada A da
memria j contm o endereo desejado
Abaixa o clock do registrador MAR
Coloca 9 (00001001) na entrada Input
O registrador In copia a sua entrada
Abaixa o clock do registrador In
A memria copia o barramento para a posio 15,
indicada pela entrada A
Abaixa o clock da memria
Libera o barramento

Figura 103: Um fluxo de dados realizvel pelo circuito da Figura 102

Exemplos de fluxos de dados realizveis com o circuito da Figura 102 so mostrados na Figura
103 e na Figura 104.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

60

Ler o contedo da posio de memria 15 (=ff) para o registrador


Out
Sinal
Input = 15
In Clk = 1
In Clk = 0
In->Dbus = 1

Comentrio
Coloca 15 (00001111) na entrada Input
O registrador In copia a sua entrada
Abaixa o clock do registrador In
O registrador In controla o barramento

MAR Clk = 1

O registrador MAR copia o barramento; a entrada A da


memria j contm o endereo desejado
Abaixa o clock do registrador MAR
A memria controla o barramento, onde coloca o
contedo da posio indicada por sua entrada A
O registrador Out copia o barramento
Abaixa o clock do registrador Out

MAR Clk = 0
RAM->Dbus = 1
Out Clk = 1
Out Clk = 0

Figura 104: Outro exemplo de fluxo de dados realizvel com o circuito da Figura 102

2.3.4

Acumuladores

Registrador
Acumulador
Circuito Soma
(combinatrio)

Figura 105: Um registrador acumulador

Um registrador pode ser usado como um acumulador, como mostrado na Figura 105. Neste
arranjo,

a entrada do acumulador alimentada por um circuito combinatrio que tipicamente


realiza operaes aritmticas ou lgicas, e
a sada do acumulador realimenta o circuito combinatrio, isto , a sada do
acumulador uma das entradas do circuito combinatrio.

Este arranjo permite, por exemplo, somar 10.000 nmeros, seqenciando as somas ao longo
do tempo.
Colocar 5 no Acumulador
Sinal
Acc Clr = 1
Acc Clr = 0
In = 5
In->Dbus = 1
Acc Clk = 1
Acc Clk = 10
In->Dbus = 0

Comentrio
Zera o acumulador
Abaixa o clear do acumulador
Coloca 5 na entrada In
A entrada In controla o barramento
O acumulador copia a entrada, que a
sada do circuito de soma, sendo = 5
Abaixa o clock do acumulador
Libera o barramento

Figura 106: Exemplo de fluxo de dados realizvel pelo circuito da Figura 105

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

61

Exemplos de fluxos de dados realizveis com o circuito da Figura 105 esto mostrados na
Figura 106 e na Figura 107.

Soma 7 (111) ao contedo do Acumulador, e transfere


o resultado para o registrador Out
Sinal
In = 7
In->Dbus = 1
Acc Clk = 1
Acc Clk = 0
In->Dbus = 0
Acc->Dbus = 1
Out Clk = 1
Out Clk = 0
Acc->Dbus = 0

Comentrio
Coloca 7 na entrada In
A entrada In controla o barramento
O acumulador copia a entrada, que a
sada do circuito de soma, sendo igual a 12
(0c em hexa), soma do valor do acumulador
com o do barramento
Abaixa o clock do acumulador
Libera o barramento
O acumulador controla o barramento
O registrador Out copia o barramento
Abaixa o clock do registrador Out
Libera o barramento

Figura 107: Outro exemplo de fluxo de dados realizvel pelo circuito da Figura 105

2.3.5

Uma Calculadora

Registrador de
Dados

Luzes para
acompanhamento

8 bits

16 bits

Unidade LgicoAritmtica

Figura 108: Circuito com as mesmas rotas de dados da CPU Pipoca

A Figura 108 mostra um circuito com alguns dos principais componentes de uma CPU. Ali
vemos, ligados a um barramento de 16 bits:

Registradores In e Out, ligados tambm a entradas e sadas de 16 bits


Um registrador de dados, o DR;
Uma memria principal com 256 palavras (e, conseqentemente no Logisim, 8 bits de
endereo) de 16 bits
Uma unidade lgico-aritmtica, que um circuito combinatrio com duas entradas,
uma ligada ao barramento e outra sada do acumulador. A ALU (Arithmetic and
Logical Unit) capaz de realizar somas, subtraes e comparaes entre suas duas

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

62

entradas. Outras operaes que uma ALU poderia fazer incluem operaes lgicas
(AND, OR, etc.) e de deslocamento (shift) de bits.
Um registrador acumulador, alimentado pela sada de resultado de operao da
unidade lgico-aritmtica;
Um registrador de resultado de comparao, tambm alimentado pela ALU.

Temos ainda o registrador MAR, que alimenta a entrada de endereo da memria principal, e
que alimentado pelos 8 bits menos significativos do barramento. A biblioteca Input/Output
do Logisim oferece leds, pequenas lmpadas que foram acrescentadas ao circuito somente
para acompanhamento visual do registrador Compare. Cada registrador, assim como a
memria principal, tem um sinal de clock; cada sada para o barramento tem um sinal que
controla a posse do barramento.
Podemos realizar diversos fluxos de dados com este arranjo, como mostram os exemplos na
Figura 109, na Figura 110 e na Figura 111.

"Ler" 7, e colocar este valor no acumulador


Comentrio
Zera o acumulador
Abaixa o clear do acumulador
Coloca 7 na entrada do registrador In
O registrador In copia sua entrada
Abaixa o clock do registrador In
A sada do registrador In colocada no barramento
O registrador ACC copia a sada da unidade lgicoaritmtica, que igual soma do contedo do
Acc Clk = 1
acumulador (igual a zero) com o valor colocado no
barramento
Acc Clk = 0
Abaixa o clock do registrador ACC
In->Dbus = 0 O barramento liberado
Sinal
Acc Clr = 1
Acc Clr = 0
Input = 111
In Clk = 1
In Clk = 0
In->DBus = 1

Figura 109: Exemplo de fluxo de dados realizvel com o circuito da Figura 108

"Ler" 6, e somar este valor ao valor do acumulador


Sinal
Comentrio
Input = 110
Coloca 6 na entrada do registrador In
In Clk = 1
O registrador In copia sua entrada
In Clk = 0
Abaixa o clock do registrador In
In->Dbus = 1 A sada do registrador In colocada no barramento
O registrador ACC copia a sada da unidade lgicoAcc Clk = 1
aritmtica, que igual soma do contedo do
acumulador com o valor colocado no barramento
Acc Clk = 0
Abaixa o clock do registrador ACC
In->Dbus = 0 O barramento liberado
Figura 110: Outro exemplo de fluxo de dados realizvel com o circuito da Figura 108

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

63

"Ler" 11, e colocar o contedo do acumulador na posio de


endereo 11 na memria
Sinal
Comentrio
Input = 1011 Coloca 11 na entrada do registrador In
In Clk = 1
O registrador In copia sua entrada
In Clk = 0
Abaixa o clock do registrador In
In->Dbus = 1 A sada do registrador In colocada no barramento
O registrador MAR copia o barramento, que passa a
MAR Clk = 1
conter o valor 11
MAR Clk = 0 Abaixa o clock do registrador MAR Clk
In->Dbus = 0 Libera o barramento
Acc->Dbus = 1 A sada do registrador ACC colocada no barramento
A memria RAM escreve o valor no barramento em
RAM Clk = 1 sua posio de endereo dada pelo contedo do
registrador MAR
RAM Clk = 0 Abaixa o clock da RAM
Acc->Dbus = 0 O barramento liberado
Figura 111: Mais um exemplo de fluxo de dados realizvel com o circuito da Figura 108

2.3.6

Osciladores ou Clocks

O motor, o propulsor de qualquer circuito digital um oscilador, ou clock. Um clock um


circuito cuja sada oscila entre 0 e 1 em uma freqncia conhecida. Um computador de 1 GHz
(1 Giga Hertz) utiliza um clock cuja sada varia entre 0 e 1, um milho de vezes por segundo.
Deste sinal bsico circuitos como registradores circulares obtm outros sinais de tempo que
so usados para coreografar o fluxo de dados de um circuito.

Figura 112: Um registrador circular

A Figura 112 mostra um registrador circular formado por quatro flip-flops tipo D alimentados
por um clock. O cabeamento tal que a sada do FF t0 est ligada entrada D do FF t1, a sada
do FF t1 entrada do FF t2, e assim por diante. A sada do FF t3 est ligada entrada do FF t0.
O registrador inicializado atravs do pino Reset, que coloca 1 no flip-flop t0, e 0 nos demais.
A cada subida do clock cada FF copia a sua entrada, o que faz com que o 1 inicialmente
armazenado no FF t0 passe para o FF t1, depois para o t2, depois para o t3, retornando ento
ao FF t0.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

64

t3
6

t2
4

t1
2

t0
0

-1
0

10

12

14

16

18

20

Figura 113: Carta de tempo para o registrador circular da Figura 112

A Figura 113 mostra a evoluo temporal de um registrador circular. importante observar


que um registrador circular pode ter quantos flip-flops se queira e que, com isso, podemos
obter sinais distribudos no tempo na forma como desejarmos.

2.4 Organizao de uma CPU


Nesta seo ns veremos como funciona uma unidade central de processamento, tambm
conhecida como UCP, ou, mais frequentemente, como CPU, do ingls Central Processing Unit.
Uma CPU o componente mais importante de um computador; a compreenso de seu
funcionamento muda a viso que temos dessas mquinas. Os conceitos que introduzimos
esto aqui ilustrados pela Pipoca, uma CPU pedaggica simulada no sistema Logisim.
O circuito da Figura 108 tem os mesmos elementos bsicos de uma CPU (veja tambm a Figura
114), com memria, barramentos e registradores controlados por sinais, e uma unidade lgico
aritmtica que realiza transformaes como somas, subtraes, etc. Um circuito assim tem
teoricamente a mesma capacidade de processamento (de transformao de informao) de
um computador. Dizemos teoricamente porque preciso que algum se disponha a manipular
os valores de entrada e os sinais de controle, como j fizemos nos exemplos de fluxos de dados
j apresentados. Ou seja, usar esse circuito para fazer a soma de 500.000 nmeros possvel,
mas no executvel por um ser humano.

Figura 114: Elementos bsicos para processamento e registradores da CPU Pipoca

A idia central de um computador a automao da emisso de seqncias de sinais de


controle segundo o desejo de uma pessoa, desejo este expresso por um programa. Queremos
Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

65

que este circuito transforme informao de maneira flexvel, com seu comportamento
moldado por um programador. Trocando-se o programa, troca-se a transformao de
informao produzida pelo circuito.

Figura 115: Um programa resolve um problema de transformao de informao

Considerando que queremos poder trocar com facilidade o programa que rege um
computador, a nica opo colocar programas em uma memria, ao invs de implementlos com circuitos. O termo software, com o prefixo soft, macio, foi um neologismo criado para
se contrapor a hardware, mais duro, constitudo por circuitos concretos. Software muito
mais flexvel.

Figura 116: Um programa deve estar codificado em bits para ser carregado em alguma memria

Alguns dos primeiros computadores tinham uma memria para programas e outra para dados,
mas na quase totalidade dos computadores atuais programas e dados so armazenados na
mesma memria, seguindo a arquitetura chamada de Von Neumann, que props este arranjo
em 1945 (Neumann, 1945).
Um programa tem um carter dual, pois ele deve ao mesmo tempo:

expressar a forma com que uma pessoa um programador pensa em resolver um


problema de transformao de informao, e
poder ser executado pelo processador, isto , por um circuito digital.

Figura 117: Programa Fonte e Programa Binrio

Na prtica estas duas demandas podem ser atendidas da seguinte maneira. Um programa
composto por instrues de mquina, que so escritas por um programador em uma
linguagem chamada Assembler, e depois traduzidas para serem executadas por uma CPU.
Isso feito por um processo que chamamos de montagem (assembly) das instrues.

Figura 118: Montagem de um programa

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores
2.4.1

66

Ciclo de Instruo

Tendo um programa carregado na memria, um computador executa repetidamente,


incansavelmente, um ciclo de instruo.

Figura 119: Ciclo de execuo de instrues

Em cada ciclo uma instruo lida da memria e executada. A execuo da instruo:

provoca alteraes nos contedos da memria e/ou dos registradores, e


determina o endereo da prxima instruo a ser executada.

A coordenao do ciclo de instruo exige novos registradores na CPU. Na Pipoca, estes so:

PC, de Program Counter, que contm o endereo da prxima instruo a ser executada
IR, de Instruction Register, que contm a instruo em execuo
Sinc Entrada e Sinc Sada, necessrios para sincronizar operaes de entrada e sada, que
veremos mais tarde.

Figura 120: A coordenao da execuo de instrues na Pipoca exige registradores extras: PC (Program Counter),
IR (Instruction Register), Sinc Sada e Sinc Entrada

Um ciclo de instruo se inicia pela leitura da instruo (ou instruction fetch) a ser executada. A
instruo lida da memria, no endereo dado pelo contedo do registrador PC, e colocada
no registrador IR.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

67

Figura 121: Leitura de uma instruo

A execuo da instruo pode modificar o contedo da memria ou dos registradores, e


determina um novo valor para o registrador PC o que significa determinar qual ser a
prxima instruo a ser executada.

Figura 122: Execuo de uma instruo

Processadores so construdos de forma tal que a prxima instruo a ser executada est
normalmente no endereo na memria subseqente ao ocupado pela instruo em execuo.
Ou seja, as instrues em princpio so executadas na mesma sequncia em que se encontram
armazenadas na memria. Instrues especiais, chamadas instrues de desvio, podem alterar
essa ordem de execuo. Desvios podem condicionais, dependendo por exemplo do resultado
de uma comparao.
Um circuito chamado unidade de controle recebe como entradas o cdigo da instruo, o
status de registradores de comparaes, um sinal de um oscilador (um clock), e se incumbe da
gerao correta dos sinais de controle correspondentes que comandam o ciclo de instruo na
CPU.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

68

Figura 123: Uma unidade de controle e um clock so necessrios para a execuo de programas

2.4.2

Instrues

Para facilitar a programao, as instrues que constituem um programa no so estruturadas


diretamente em termos de sinais de controle o que entretanto se poderia esperar, visto que
a emisso destes sinais o efeito final necessrio para se produzir uma computao. Aes
tpicas de instrues de mquina so somar o contedo da posio X de memria ao
acumulador, ou ler um dado em pinos de entrada e colocar na posio de memria Y, com
mais significado para o programador. A emisso efetiva dos sinais de controle fica definida
pelo que chamamos de micro-instrues. A execuo de uma instruo feita atravs da
execuo de vrias micro-instrues, como veremos a seguir.

15 14 13 12 11 10
OpCode
Mode

5
4
3
Operand

Figura 124: Formato de uma instruo da Pipoca

Ns vimos que instrues devem ser codificadas tambm em bits. A Figura 124 mostra o
formato que escolhemos para as instrues da Pipoca. Cada instruo tem 16 bits, sendo 4
para o cdigo da instruo, 2 para o modo de endereamento (que explicaremos a seguir) e 10
para um operando.
Instrues so definidas em termos de alteraes na viso que um programador tem da CPU.
O conjunto completo de instrues da Pipoca est mostrado na Tabela 12. So 11 instrues
ao todo. Como dispomos de 4 bits para o cdigo da instruo, temos ainda espao para quatro
outras instrues, que podem vir a ser implementadas em novas verses.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

69

Adiciona o operando a ACC, deixando o resultado em ACC


Compara o operando com ACC e coloca o resultado em Compare
Para a execuo do programa
Espera InFull = 1, e transfere o valor de Input para a palavra apontada
pelo operando; faz InFull = 0
Desvia para a palavra apontada pelo operando
Desvia para a palavra apontada pelo operando se "D=ACC" = 1
Desvia para a palavra apontada pelo operando se "D>ACC" = 1
Desvia para a palavra apontada pelo operando se "D<ACC" = 1
Carrega o operando no acumulador
Espera OutEmpty = 1, e transfere o operando para o registrador
Output; faz OutEmpty = 0
Transfere o valor de ACC para a palavra apontada pelo operando
Subtrai o operando de ACC, deixando o resultado em ACC

BranchAddr16

OpCode2

OpCode10

Description

Mnemonic

Tabela 12: Conjunto de instrues da Pipoca

ADD
COMPARE
HALT

0 0000 18
1 0001 1C
2 0010 45

INPUT
JMP
JMPEQ
JMPGT
JMPLT
LOAD

3
4
5
6
7
8

0011
0100
0101
0110
0111
1000

OUTPUT
STORE
SUB

9
10
11
12
13
14
15

1001 36
1010 3B
1011 41
1100
1101
1110
1111

Estes cdigos podem ser usados para novas instrues

20
27
2B
2D
2F
31

Nessa tabela,

o campo Description descreve o efeito da instruo;


o campo Mnemonic contm cdigos para cada instruo, que so empregados por um
programador ao construir um programa;
o campo OpCode10 enumera as instrues e, com isso, fornece um cdigo para cada
uma delas;
o campo OpCode2 contm os mesmos valores de OpCode10, mas codificados em
binrio de 4 bits, destinados ao uso por computadores;
O campo BranchTable16 ser explicado mais tarde.

Voltando Figura 124, os dois bits do modo de endereamento modificam a interpretao do


campo de operando conforme a Tabela 13.
Tabela 13: Modos de endereamento nas instrues da Pipoca

00 Endereamento imediato. O valor codificado no campo operando deve ser usado


diretamente para a operao definida pela instruo.
01 Endereamento direto. O valor a ser usado na operao definida pela instruo o
contedo da posio de memria cujo endereo est no campo operando da instruo.
10 Endereamento indireto. O valor a ser usado na operao definida pela instruo o
contedo da posio de memria cujo endereo est na posio de memria cujo endereo
est no campo operando da instruo.
11 Este cdigo para o modo de endereamento no utilizado na Pipoca.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

70

Memria
7

23

Cdigo

23

41

Modo Operando

ADD

Imediato

ADD

Direto

ADD

Indireto

Efeito
Soma 7 ao
acumulador
Soma 23 ao
acumulador
Soma 41 ao
acumulador

Figura 125: Modos de endereamento

Supondo que em um dado instante a posio 7 da memria contenha o valor 23, e que a
posio 23 da memria contenha o valor 41, uma instruo ADD com o valor 7 codificado em
seu campo de operando ter como efeito:

Se o endereamento for imediato, somar 7 ao contedo do acumulador;


Se o endereamento for direto, somar o contedo da posio 7 da memria ao registrador
no caso, somar 23 ao acumulador;
Se o endereamento for indireto, somar o contedo da posio dada pelo contedo da
posio 7 ao acumulador no caso, somar 41 ao acumulador.

2.4.3

Programao em Assembler

Um programa executvel um mapa da memria, contendo instrues e dados codificados


em binrio. Entretanto, nenhum ser humano com sade mental consegue fazer um programa
diretamente em binrio. O processo de programao em Assembler consiste em:

preencher uma tabela com os mnemnicos das instrues, dando nomes a posies de
memria e usando esses nomes como operandos, sendo assim mais compreensvel
para humanos, e
depois, substituir esses mnemnicos e nomes de posies de memria pelos cdigos
binrios correspondentes, um processo a que damos o nome de montagem.

O programa em binrio deve ser gravado em alguma mdia hoje em dia, um arquivo,
antigamente, fitas de papel ou cartes perfurados e, no momento da execuo, ser
carregado na memria do computador. Na Pipoca, simulada no Logisim, isso equivale carga
de uma imagem na memria principal, o que possvel fazer clicando com o boto direito do
mouse sobre o componente memria. Em computadores reais so programas chamados
loaders que se incumbem de ler mdias com programas binrios e carreg-los na memria.
Um mesmo programa tem portanto trs formas:

Programa Fonte, que um texto em formato tabular, escrito e legvel por humanos;
Programa Executvel, que resulta da montagem do programa fonte, e normalmente
um arquivo com uma imagem da memria. No Logisim, um programa executvel um
arquivo ASCII onde cada linha representa uma palavra da memria, codificada em
hexadecimal, e
Programa em Execuo, que um conjunto de palavras na memria principal.

A Tabela 14 mostra o cdigo fonte do programa SumX, cuja funcionalidade consiste em somar
os valores na memria entre o endereo X e o endereo XEND. Ns vemos ali que o cdigo das
instrues (do endereo 0 ao endereo 14) est junto com os dados (do endereo 15 ao 21).

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

71

Esses dados consistem no vetor X, que ocupa as posies de 15 a 19, e em duas outras
posies: SUM, que ir conter a soma desejada, e P, que ser utilizado para enderear a
parcela de X que somada em cada passo da execuo do programa. Na Pipoca, o programa
comea a ser executado pela instruo na posio 0 da memria.
O programa SumX tem:

Uma etapa de inicializao das variveis (posies de memria) SUM e P, formada


pelas instrues nos endereos de 0 a 3, e que atribui o valor inicial 0 para SUM, e
coloca em P o endereo X.
Um loop composto pelas instrues colocadas entre o endereo 4 e o endereo 12. Em
cada passo deste loop uma das parcelas adicionada a SUM, e o endereo
armazenado em P incrementado. Ao fim do passo P comparado com XEND e,
dependendo do resultado, o loop repetido ou o programa passa para a sua fase final.
Uma etapa de finalizao, onde o resultado da soma encaminhado para a sada e o
programa pra.

XEND
SUM
P
Figura 126: Uso das variveis SUM e P no programa SumX.

As quatro ltimas colunas na Tabela 14 resultam de um processo de montagem que


descrevemos a seguir.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

72
Tabela 14: O programa SumX

2.4.4

Montagem do Programa Executvel

Instruo
Cdigos
Binrio
Hexa

OpCode Mode
Operand
LOAD
1
SUM
1000
01
0000010100
1000 0100 0001 0100
8414

Vem da tabela de
cdigos de instruo

SUM o nome dado


posio x14 da memria

Figura 127: Montagem de uma instruo

A converso para binrio de uma linha de cdigo como LOAD 1 SUM se faz pelas etapas
abaixo, ilustradas na Figura 127:

Na Tabela 12 vemos que o cdigo da instruo LOAD 1000.


O modo de endereamento codificado em binrio com 2 bits 01.
Olhando o programa na Tabela 14, ns vemos que SUM o nome (label) dado
posio 20 de memria, que, em binrio de 10 bits, 0000010100.
A converso completa resulta da concatenao (justaposio) desses trs binrios,
resultando em 1000010000010100 ou, em hexadecimal, 8414.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

73

Como voc pode ter percebido, a traduo da tabela-programa para binrio uma tarefa
insana. Mas essa tarefa s foi feita manualmente pelos pioneiros da computao com , pelos
parmetros atuais, enormes custos de verificao e baixssima produtividade dos
programadores. Mas cedo se percebeu que computadores eram muito bons para ... auxiliar a
programao de computadores! Um montador (um assembler) um programa que l uma
tabela-programa, e gera imagens binrias a serem carregadas nas memrias, automatizando o
processo ilustrado na Figura 127.

Figura 128: O programa SumX, como um arquivo de imagem de memria do Logisim e carregado na memria

A Pipoca um circuito simulado no Logisim, onde mapas de memria podem ser carregados
clicando sobre a memria com o boto direito do mouse e escolhendo a opo Load Image,
que abre um dilogo para escolha de um arquivo como o mostrado na Figura 128. Arquivos
como esse podem ser produzidos usando a planilha Pipoca.xls, disponvel no site do curso, e
aqui utilizada como um assembler.
2.4.5

O Circuito Principal da CPU Pipoca

J temos agora condies de apresentar o circuito principal da CPU Pipoca, mostrado na Figura
129.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

74

Figura 129: O circuito principal da CPU Pipoca

Complicado? Sem dvida, mas vamos por partes; mingau quente se come pelas beiradas.
Primeiramente, voc deve reparar que neste circuito o principal complicador a unidade de
controle, o retngulo vertical na parte inferior do circuito. Para ali vo muitos fios, e dali saem
outros tantos. Isto no de se estranhar, posto que a funo da unidade de controle , como
dissemos, levantar os sinais de controle na sequncia e tempos adequados para a implantao
dos fluxos de dados que implementam as instrues de mquina. Como exemplos, esto
destacados na Figura 129 cabeamentos para o sinal de clock do acumulador (em azul), para a
tomada do barramento de dados pelo registrador Input (em vermelho) e para o campo
operando da instruo (em marrom). O conjunto completo de entradas e sadas da unidade de
controle est mostrado na Figura 130.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

75

Estado da
CPU

Propulsor

21 sinais de
controle
Figura 130: Entradas e sadas da unidade de controle

O circuito principal da CPU Pipoca tem ainda circuitos auxiliares para sincronizao de entrada
e sada, colocados na parte superior do diagrama, e um circuito para depurao (debug) de
programas, no canto inferior direito que, bloqueando o sinal de clock, permite que a execuo
de um programa se interrompa ao trmino de cada instruo executada.
Flip-flop
Set/Reset

Sinal acionado
pelo dispositivo
de entrada

Sinal acionado
pela Unidade
de Controle

Vai para a
Unidade de
Controle

Figura 131: Circuito para sincronizao da CPU com dispositivo de entrada

O circuito mostrado na Figura 131 realiza a sincronizao da CPU com o (nico, na Pipoca)
dispositivo de entrada. A sincronizao necessria porque, com a execuo automtica e
incessante de instrues pela CPU, existe tanto a possibilidade de captura de dados nos pinos
de entrada antes que estejam prontos, como a de captura repetida de um mesmo dado de
entrada, como ainda a de mudana de dados pelo dispositivo de entrada antes de serem lidos
pela CPU. O protocolo seguido pela CPU e pelo dispositivo prescreve as seguintes regras:

Somente o dispositivo de entrada aciona o sinal SetInFull, e somente a CPU aciona o


sinal SetInEmpty;
O dispositivo de entrada somente aciona SetInFull quando o dado de entrada est
pronto e InFull = 0, e a CPU (atravs da Unidade de Controle) somente aciona

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

76

SetInEmpty quando InFull = 1 (ou InEmpty = 0), o que feito aps a leitura dos dados
de entrada;
O circuito inicializado com InFull = 0.

O circuito de sincronizao com o dispositivo de sada similar a este.


Na Pipoca, as instrues INPUT e OUTPUT exigem interveno do usurio, que deve usar a
ferramenta de manipulao do Logisim para escolher valores de entrada e tambm para
sincronizar dispositivos externos, apertando convenientemente os botes SetInFull(para
avisar que um valor de entrada est pronto para ser lido) e SetOutEmpty(para avisar que um
valor colocado anteriormente no registrador Output j foi consumido).
Programas podem ser executados instruo por instruo, o que muito til para a depurao
(debug) de erros. Para isto, preciso colocar o valor 1 na entrada Debug, e apertar o boto
Run a cada vez que uma nova instruo carregada no registrador de instruo.
Se retirarmos a Unidade de Controle da CPU Pipoca, retornando emisso manual dos sinais
de controle, e se retirarmos tambm os circuitos de sincronizo de entrada e sada, teremos
um circuito como o da Figura 132. Comparando com o circuito da Figura 108 voc pode
observar que:

foi acrescentado um registrador de instrues, o IR (Instruction Register) que tem a


funo de armazenar a instruo em execuo num dado instante;
temos um barramento de endereos, o ABus, alm do barramento de dados DBus;
com a entrada ligada ao barramento de dados , e com a sada ligada ao barramento de
endereos, ns vemos o registrador PC (Program Counter), que armazena o endereo
da prxima instruo a ser executada; ns veremos adiante a lgica de funcionamento
do PC;
temos tambm conjuntos de leds ligados a decodificadores que no tm funo na
lgica do circuito, mas nos ajudam a visualizar qual instruo est em execuo e qual
o modo de endereamento empregado na instruo corrente.

Registrador de
Instrues
ABus

Contador de
Programa

DBus
Figura 132: Rotas de dados na CPU Pipoca

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores
2.4.6

77

O Contador de Programa

Outro subcircuito da CPU Pipoca o contador de programa, mostrado na Figura 133.

Figura 133: O contador de programa

Nesse circuito observamos que:

o sinal Clock faz com que o registrador copie a sua entrada, que alimentada pela
sada de um multiplexador;
este multiplexador escolhe, segundo a entrada Force New Address, entre o valor
corrente do registrador acrescido de 1 (resultado da operao de soma) e o valor
constante na entrada New Address.

A unidade de controle se encarrega de colocar nessas entradas os valores adequados nos


tempos corretos.
2.4.7

A Unidade de Controle

Figura 134: O papel da Unidade de Controle

A Figura 134 ilustra a funo da unidade de controle, que pode ser vista com mais detalhes no
circuito da Figura 130. Para cumprir este papel a unidade de controle da Pipoca possui como
principais componentes:

um circuito Timing que fornece os sinais de tempo que conduzem a seqncia de


eventos na unidade de controle,
uma memria ROM (Read Only Memory) que contm uma tabela de desvios, a Branch
Table, cuja funo explicaremos a seguir,

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

78

uma outra ROM que abriga o microprograma, e


registradores da unidade de controle.

Figura 135: Componentes da Unidade de Controle

Os registradores da unidade de controle da Pipoca so:

o mPC (micro Program Counter), que contm o endereo da micro-instruo em


execuo,
o mIR (micro Instruction Register), que armazena a micro-instruo em execuo,
o registrador Signals, cuja sada tambm a sada da unidade de controle, e que
fornece os sinais de controle para a CPU,
e o Return Address, que usado para permitir o uso de sub-rotinas, isto , de
sequncias de micro-instrues que so reaproveitadas, como veremos a seguir.

Figura 136: Registradores da Unidade de Controle

A unidade de controle utiliza uma tcnica conhecida como microprogramao para produzir os
sinais de controle que, emitidos nos momentos adequados para barramentos, registradores e
memria, executam efetivamente os fluxos de dados que correspondem s instrues.

t
23

mOpCode
22

21

20

Reserve
19 18 17 16 15 14 13 12 11 10

mOperand
9

Signals
Figura 137: Formato de uma microinstruo

Em uma CPU microprogramada uma instruo executada como uma sequncia de


microinstrues. Microinstrues da Pipoca tm 24 bits, no formato mostrado na Figura 137.
Temos dois tipos de microinstrues:

microinstrues de sinal, onde os bits de 0 a 22 so valores para os sinais de controle


(clocks de registradores e memrias, controles de barramentos) que a unidade de
controle deve prover para o circuito principal da CPU, ou

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

79

microinstrues de desvio, que so utilizadas para guiar o fluxo de execuo das


microinstrues.

O tipo da microinstruo ditado pelo bit mais significativo, o bit 23.


Tabela 15: Microinstrues de Desvio

m-Instruction DEC BIN

Effect
Desvia para a micro-instruo inicial da
instruo no registrador IR da CPU
Desvia para o operando se o modo de
endereamento for Imediato
Desvia para o operando se o modo de
endereamento for Direto
Desvia para o operando se o modo de
endereamento for Indireto
Situao inesperada - no deveria
acontecer. Acende um led.
Desvia para a micro-instruo apontada
pelo registrador Return Addr
Desvia para o operando e armazena o
endereo consecutivo no Return Addr
Desvia para o operando se D = ACC for
igual a 1
Desvia para o operando se D > ACC for
igual a 1
Desvia para o operando se D < ACC for
igual a 1
Desvia para o operando
incondicionalmente

jmpNext

0 0000

jmpIMMEDIATE

1 0001

jmpDIRECT

2 0010

jmpINDIRECT

3 0011

error

4 0100

return

5 0101

jsr

6 0110

jmpEQ

7 0111

jmpGT

8 1000

jmpLT

9 1001

jmp

10 1010

jmpInEmpty

11 1011 Desvia para o operando se InEmpty = 1

jmpOutFull

12 1100 Desvia para o operando se OutFull = 1


13 1101
14 1110

Estes cdigos podem ser usados em


novas microinstrues

15 1111

Instrues podem ter etapas comuns em sua execuo, como a obteno do operando
conforme o modo de endereamento. O micro-cdigo destas etapas reaproveitado usando a
micro-instrues jsr (jump to subroutine), que desvia para o endereo dado por seu operando,
e armazena o endereo atual acrescido de 1 no registrador Return Address, e a microinstruo return, que desvia para o endereo armazenado no registrador Return Address.
O circuito da unidade de controle pode ser visto na Figura 138, onde se pode destacar:

as entradas
o Opcode, com o cdigo da instruo corrente,
o Mode, com o modo de endereamento,
o In Empty, Out Full, com o estado dos registradores de sincronizao de entrada
e sada,

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

80

D>ACC, D=ACC, D<ACC, com o resultado da ltima instruo COMPARE


executada, e
o Reset Clock e CLOCK, que servem para inicializar o circuito Timing e para dar
vida CPU;
as sadas com sinais que controlam o fluxo de dados na CPU;
a memria ROM Microprogram, que abriga o microprograma, com 256 palavras de 24
bits;
a memria ROM Branch Table, com 16 palavras de 8 bits, que armazena para cada
cdigo de instruo (Opcode) o endereo da primeira microinstruo a ser executada
para a execuo da instruo;
o registrador mIR (micro Instruction Register), com 24 bits, que armazena a microinstruo corrente;
o circuito mPC (micro Program Counter), que funciona de forma anloga ao contador
de programa da CPU;
o registrador Return Addr, de 8 bits, que armazena o endereo de retorno para uma
micro-instruo jsr;
o circuito Timing, inicializado pela entrada Reset Clock e alimentado pelo CLOCK, que
ciclicamente oferece os sinais t0, t1 e t2;
o registrador Signals, que armazena os sinais utilizados no controle do fluxo de dados
da CPU;
um splitter ligando o registrador Signals aos pinos de sada;
um decodificador de cdigo de instruo;
um decodificador de modo de endereamento;
portas lgicas que essencialmente implementam decises de desvio no fluxo de microinstrues;
e alguns leds que animam a festa.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

ROM
Branch Table

81

Endereo de
Retorno para jsr

Micro Program
Counter
ROM
Microprograma

Timing
Figura 138: A unidade de controle

2.4.8

O Ciclo de Micro-Instruo

Um ciclo de instruo na verdade implementado por diversos ciclos de micro-instruo, que,


de forma similar aos ciclos de instruo, so compostos por etapas de leitura e de execuo de
micro-instrues que se alternam indefinidamente.

Figura 139: Ciclo de micro-instruo

Na etapa de leitura, uma micro-instruo lida na ROM de microprograma, no endereo


apontado pelo registrador mPC, e a instruo lida armazenada no registrador mIR.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

82

Figura 140: Leitura de uma micro-instruo

A execuo da micro-instruo pode alterar os valores dos registradores da unidade de


controle e, em particular, do registrador Signals que, como vimos, emite os sinais de controle
para a CPU, e do registrador mPC, determinando assim a prxima micro-instruo a ser
executada.

Figura 141: Execuo de uma micro-instruo

O mIR tem a interpretao de sua sada dependente do tipo da micro-instruo.

Figura 142: Sada do registrador mIR

O ciclo de micro-instruo comandado pelos sinais emitidos pelo circuito Timing.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

83

Figura 143: Sinais do ciclo de micro-instruo

O circuito Timing est mostrado na Figura 144, sendo similar ao circuito da Figura 112.

Figura 144: O circuito Timing

As observaes abaixo podem ajudar a compreender o funcionamento da unidade de controle:


O circuito Timing gera ciclicamente os sinais t0, t1 e t2;
Quanto t0 passa de 0 para 1 (veja o destaque em vermelho na Figura 138), a
microinstruo no endereo apontado por mPC carregada no mIR;

Figura 145: Aes em t0

Quando t1 passa de 0 para 1 (destaque em verde na Figura 138), se a microinstruo


for do tipo signal, seu operando carregado no registrador Signals, cujas sadas
fornecem os sinais de controle para a CPU; seno, se a microinstruo for jsr (jump
subroutine), o valor do mPC acrescido de 1 armazenado no registrador Return
Address

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

84

Figura 146: Aes em t1

Quando t2 passa de 0 para 1 (destaque em azul na Figura 138), o clock do mPC


acionado, atualizando seu contedo, o que determina a prxima micro-instruo a ser
executada. O novo contedo depende do sinal aplicado entrada Force New Address
do mPC:
o se for igual a 0, ser o endereo consecutivo ao contedo anterior;
o se for igual a 1, ser o contedo da entrada New Address do mPC;
O circuito que decide o valor aplicado entrada Force New Address um OR de vrias
clusulas:
o a microinstruo corrente jmp, jmpNext, ou return, ou jsr;
o a microinstruo corrente jmpImmediate e o modo de endereamento
Immediate, ou a microinstruo jmpDirect e o modo de endereamento
Direct, ou a microinstruo jmpIndirect e o modo de endereamento
Indirect;
o a microinstruo corrente jmpGT e D>ACC = 1, ou jmpEQ e D=ACC = 1, ou
jmpLT e D<ADD = 1;
o a microinstruo corrente jmpInFull e InFull = 1, ou jmpOutEmpty e
OutEmpty = 1.

Figura 147: Aes em t2

Quanto ao contedo da entrada New Address do mPC, isto , quanto ao endereo da


prxima microinstruo a ser executada no caso de desvio, ele ser:
Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores
o

85

o contedo da memria Branch Table no endereo dado por OpCode se a


microinstruo corrente for jmpNext,

Figura 148: Efeito da micro-instruo jmpnext

o
o

o contedo do registrador Return Address se a microinstruo corrente for


return,
o contedo do campo operando da microinstruo se esta for jmp ou jsr, ou se
a microinstruo for jmp<condio> e <condio> for igual a 1.

Micro-programa
Branch Table
ADD
COMPARE
HALT
INPUT
JMP
JMPEQ
JMPGT
JMPLT
LOAD
OUTPUT
STORE
SUB

0
1
2
3
4
5
6
7
8
9
10
11

18
1C
45
20
27
2B
2D
2F
31
36
3B
41

18
Micro-instrues
para ADD
1C
Micro-instrues
para COMPARE
45

Micro-instrues
para HALT

Figura 149: A Branch Table e o micro-programa

...

A Figura 149 mostra o relacionamento entre a Branch Table e o micro-programa.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores
2.4.9

86

O Micro-Programa

Figura 150: Construo do micro-programa e da Branch Table

Micro-programas tambm so feitos por humanos, os projetistas do computador. O processo


de micro-programao consiste no preenchimento de uma tabela utilizando uma linguagem
comumente chamada micro-assembler. Nesta linguagem utilizam-se labels para se referir a
posies na memria de micro-programa, mnemnicos para as micro-instrues de desvio, e
indicaes explcitas de quais sinais devem ser ativados para as micro-instrues de sinal.
A tabela obtida o micro-programa fonte, legvel por humanos, a partir do qual processos de
montagem produzem o micro-programa binrio e tambm a Branch Table.

Fetch

jmpNext

mOpCode
22

21

20

Reserve

mOperand

19 18 17 16 15 14 13 12 11 10 9

0
0
0
0
1

SetOutFull
SetInEmpty
In Clk
In->DBus
Out Clk
RAM Clk
RAM->DBus
IR Clk
Operand->DBus
PC Clk
PC Force
PC->ABus
MAR->Abus
MAR Clk
ACC Clk
ACC Clear
ACC->Dbus
Subtract
Comp Clk
DR Clk
DR->Dbus

New Signal
New Signal

Type

Signals

mOperand

0
1
2
3
4

m-Instruction

Address

00
01
02
03
04

Label

Addr(HEX)

t
23

1
1

1
1
1

1
1

Comments

Sada do PC vai para Abus


Sada da RAM vai para Dbus
IR copia o Dbus
PC avana
Inicia a execuo da instruo armazenada no IR

Figura 151: Micro-cdigo para fetch de instruo

A Figura 151 mostra o micro-cdigo que implementa a leitura (fetch) de uma nova instruo.
Este micro-cdigo executado ao fim de cada instruo; todas as instrues sempre terminam
pela micro-instruo jmp Fetch. Repare que a ltima micro-instruo de Fetch jmpNext que,
como vimos, desvia para a posio apontada pela sada da ROM Branch Table.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

41
42
43
44

20

Reserve

mOperand

19 18 17 16 15 14 13 12 11 10 9

jmp

Fetch

jmpNext
GetOperand

jmp

Fetch

1
0
0
0
0
0
1
0
1

SetOutFull
SetInEmpty
In Clk
In->DBus
Out Clk
RAM Clk
RAM->DBus
IR Clk
Operand->DBus
PC Clk
PC Force
PC->ABus
MAR->Abus
MAR Clk
ACC Clk
ACC Clear
ACC->Dbus
Subtract
Comp Clk
DR Clk
DR->Dbus

jsr

21

New Signal
New Signal

65 SUB
66
67
68

GetOperand

Type

jsr

mOperand

24 ADD
0 Fetch
25
1
26
2
27
3
4

mOpCode
22

Signals

m-Instruction

Label

18
00
19
01
1A
02
1B
03
04

Address

Addr(HEX)

t
23

87

1
1

1
1
1

Resolve endereamento; operando efetivo no DR


Sada do PC vai para Abus
1 Sada do DR vai para Dbus
Sada da RAM vai para Dbus
1 ACC copia sada da ALU
IR copia o Dbus
Fetch da prxima instruo
PC avana
Inicia a execuo da instruo armazenada no IR

1
0
0
1

Comments

Resolve endereamento; operando efetivo no DR


1 Sada do DR vai para Dbus; pino Subtract da ALU = 1
1 ACC copia a sada da ALU (=ACC - Dbus)
Fetch da prxima instruo

1
1

Figura 152: Micro-cdigo para as instrues ADD e SUB

Na Figura 152 ns vemos o micro-cdigo das micro-instrues ADD e SUB. Ele se inicia com a
micro-instruo jsr GetOperand; o micro-cdigo de GetOperand (Figura 153) se encarrega de
resolver o modo de endereamento, colocando o operando efetivo da instruo no registrador
DR.

21

Immediate
Direct
Indirect
GetOperand

20

Reserve

mOperand

19 18 17 16 15 14 13 12 11 10 9

SetOutFull
SetInEmpty
In Clk
In->DBus
Out Clk
RAM Clk
RAM->DBus
IR Clk
Operand->DBus
PC Clk
PC Force
PC->ABus
MAR->Abus
MAR Clk
ACC Clk
ACC Clear
ACC->Dbus
Subtract
Comp Clk
DR Clk
DR->Dbus

New Signal
New Signal

10
11
12 Direct
13
14
15
16
17 Indirect
18
19
20
21
22
23

Fetch
GetOperand
jmpIMMEDIATE
jmpDIRECT
jmpINDIRECT
error
Immediate jmpNext

Type

0A
0B
0C
0D
0E
0F
10
11
12
13
14
15
16
17

mOperand

0
5
1
6
2
7
3
8
4
9

mOpCode
22

Signals

m-Instruction

Address

00
05
01
06
02
07
03
08
04
09

Label

Addr(HEX)

t
23

0
1
0
1
0
1
0
1
1
0

1
1

return

return

Sada do PC vai para Abus


Sada dapara
RAM
vai para Dbus apropriadas
Desvia
micro-instrues
IR copia o Dbus
PC avana
Modo
de endereamento inexistente??!!
Inicia
a execuo
da instruo
armazenada
O
operando
da instruo
vai para
o Dbus no IR
DR copia o Dbus
Retorna
O operando da instruo vai para o Dbus
MAR copia o Dbus; sada do MAR vai para o Abus
Sada da RAM vai para Dbus
DR copia o Dbus
Retorna
O operando da instruo vai para o Dbus
MAR copia o Dbus; sada do MAR vai para o Abus
Sada da RAM vai para Dbus
MAR copia o Dbus; sada do MAR vai para o Abus
Sada da RAM vai para Dbus
DR copia o Dbus
Retorna

1
1

0
1
0
0
0
0
1
0
0
0
0
0
0
1

return

1
1
1

1
1
1
1
1
1
1
1
1
1

1
1
1

1
1
1
1
1

Comments

1
1

Figura 153: Micro-cdigo para a subrotina GetOperand

Com exceo da instruo HALT, o micro-cdigo de todas as outras micro-instrues invoca a


sub-rotina GetOperand. No incio da execuo de GetOperand feito um desvio para
sequncias micro-instrues que emitem os sinais de controle necessrios para a obteno do
operando segundo o modo de endereamento. Essas sequncias tm os labels Immediate,
Direct e Indirect, e todas as trs terminam com uma micro-instruo return, que retorna para o
ponto onde a GetOperand foi chamada.

00
27
01
28
02
29
03
2A
04
2B

2C
2D
2E
2F
30

0 Fetch
39
JMP
1
40
2
41
3
42
4 JMPEQ
43
44
45 JMPGT
46
47 JMPLT
48

jsr

jmp
jmpNext
jmpEQ
jmp
jmpGT
jmp
jmpLT
jmp

mOpCode
22

21

20

Reserve

mOperand

19 18 17 16 15 14 13 12 11 10 9

GetOperand

Fetch
JMP
Fetch
JMP
Fetch
JMP
Fetch

0
1
0
0
0
1
1

SetOutFull
SetInEmpty
In Clk
In->DBus
Out Clk
RAM Clk
RAM->DBus
IR Clk
Operand->DBus
PC Clk
PC Force
PC->ABus
MAR->Abus
MAR Clk
ACC Clk
ACC Clear
ACC->Dbus
Subtract
Comp Clk
DR Clk
DR->Dbus

New Signal
New Signal

Type

Signals

mOperand

m-Instruction

Label

Address

Addr(HEX)

t
23

1
1

1
1

1
1

1
1
1

1
1
1
1
1

Comments

Sada do endereamento;
PC vai para Abus operando efetivo no DR
Resolve
da RAM
para
Dbusfora desvio no PC
1 Sada do
DR vaivaipara
Dbus;
IR copia
Dbus
1 PC
copiaoDbus
PC avana
Fetch
da prxima instruo
Inicia a condicional
execuo dapara
instruo
Desvio
JMP armazenada no IR

Fetch da prxima instruo


Desvio condicional para JMP
Fetch da prxima instruo
Desvio condicional para JMP
Fetch da prxima instruo

Figura 154: Micro-cdigo para as instrues JMP, JMPEQ, JMPGT e JMPLT

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

88

O micro-cdigo para as instrues de desvio est mostrado na Figura 154. Repare que o microcdigo das instrues de desvio condicional se inicia pelas micro-instrues de desvio
condicional correspondentes. Se a condio de desvio no estiver satisfeita, nada acontece e a
micro-instruo jmp Fetch executada para a leitura da prxima instruo.

t
23

21

20

Reserve

mOperand

19 18 17 16 15 14 13 12 11 10 9

jmp

Fetch

36
37
38
39
3A

54 OUTPUT
55 OutLoop
56
57
58

jsr
jmpOutFull

GetOperand
OutLoop

jmp

Fetch

GetOperand
InLoop

jmpNext

SetOutFull
SetInEmpty
In Clk
In->DBus
Out Clk
RAM Clk
RAM->DBus
IR Clk
Operand->DBus
PC Clk
PC Force
PC->ABus
MAR->Abus
MAR Clk
ACC Clk
ACC Clear
ACC->Dbus
Subtract
Comp Clk
DR Clk
DR->Dbus

jsr
jmpInEmpty

New Signal
New Signal

Address

0 INPUT
Fetch
32
1 InLoop
33
2
34
3
35
4
36
37
38

Type

Addr(HEX)

mOperand

m-Instruction

Signals

00
20
01
21
02
22
03
23
04
24
25
26

Label

mOpCode
22

0
1
0
1
0
0
1
0
0
1

1
1

1
1
1

1
1

1
1

1
1
0
0
1

1
1

1
1
1

Comments

Sada do endereamento;
PC vai para Abus operando efetivo no DR
Resolve
Sada daInEmpty
RAM vai= para
Espera
0 Dbus
IR copia
Dbus
1 Sada
dooDR
vai para Dbus
PC avana
1 MAR
copia o Dbus; sada do MAR vai para o Abus
Inicia
a execuo
instruo
armazenada
In
copia
a entrada;dasada
do In vai
para Dbusno IR
Zera o FF InEmpty; RAM copia o Dbus
Fetch da prxima instruo

Resolve endereamento; operando efetivo no DR


Espera OutFull = 0
1 Sada do DR vai para Dbus
1 Zera o FF OutFull; Out copia Dbus
Fetch da prxima instruo

Figura 155: Micro-cdigo para as instrues INPUT e OUTPUT

Na Figura 155 ns vemos o micro-cdigo para as instrues INPUT e OUTPUT que, logo aps a
obteno do operando, executam um loop de espera composto por uma nica microinstruo, que executada repetidamente (atravs de um desvio condicional para ela mesma)
at que a condio de sincronizao de entrada ou de sada esteja satisfeita.

GetOperand

jmpNext
jmp

Fetch

jsr

GetOperand

jmp

21

Fetch

20

Reserve

mOperand

19 18 17 16 15 14 13 12 11 10 9

SetOutFull
SetInEmpty
In Clk
In->DBus
Out Clk
RAM Clk
RAM->DBus
IR Clk
Operand->DBus
PC Clk
PC Force
PC->ABus
MAR->Abus
MAR Clk
ACC Clk
ACC Clear
ACC->Dbus
Subtract
Comp Clk
DR Clk
DR->Dbus

New Signal
New Signal

59 STORE
60
61
62
63
64

Type

3B
3C
3D
3E
3F
40

jsr

mOperand

0 LOAD
Fetch
49
1
50
2
51
3
52
4
53

mOpCode
22

Signals

m-Instruction

Address

00
31
01
32
02
33
03
34
04
35

Label

Addr(HEX)

t
23

0
0
1
0
0
1

1
1

1
1
1

1
0
0
0
0
1

Sadaodo
PC vai para Abus
Zera
ACC
Sada da endereamento;
RAM vai para Dbus
Resolve
operando efetivo no DR
IR copia
Dbus
1 Sada
dooDR
vai para Dbus
PC avana
1 ACC
copia sua entrada (= 0 + Dbus)
Inicia adaexecuo
instruo armazenada no IR
Fetch
prxima da
instruo

1
1
1

Comments

Resolve endereamento; operando efetivo no DR


1 Sada do DR vai para Dbus
1 MAR copia o Dbus; sada do MAR vai para o Abus
Sada do ACC vai para Dbus
RAM copia o Dbus
Fetch da prxima instruo

1
1
1

Figura 156: Micro-cdigo para as instrues LOAD e STORE

O micro-cdigo para as instrues LOAD e STORE est mostrado na Figura 156, e no


apresenta novidades.

jmp

jmpNext

HALT

21

0
0
1
0
0
1

20

Reserve

mOperand

19 18 17 16 15 14 13 12 11 10 9

SetOutFull
SetInEmpty
In Clk
In->DBus
Out Clk
RAM Clk
RAM->DBus
IR Clk
Operand->DBus
PC Clk
PC Force
PC->ABus
MAR->Abus
MAR Clk
ACC Clk
ACC Clear
ACC->Dbus
Subtract
Comp Clk
DR Clk
DR->Dbus

New Signal
New Signal

Type

mOperand

0 Fetch
1 HALT
69
2
3
4

mOpCode
22

Signals

m-Instruction

Address

00
01
45
02
03
04

Label

Addr(HEX)

t
23

1
1

1
1
1

Figura 157: Micro-cdigo1para a instruo HALT

Comments

Sada do PC vai para Abus


Sada infinito
da RAM-vai
para final
Dbus
Loop
parada
IR copia o Dbus
PC avana
Inicia a execuo da instruo armazenada no IR

A instruo HALT implantada por uma micro-instruo de desvio incondicional para ela
mesma, o que coloca a CPU em um loop infinito, e para o processamento.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

89

2.4.10 A Planilha Pipoca.xls


Para funcionar a Pipoca depende de ter preenchidas suas memrias RAM e ROM, o que pode
ser feito no Logisim atravs da carga de arquivos com mapas de memria. Mas como fazer
para obter mapas que correspondem a uma inteno do projetista de instrues ou do
programador? Sua codificao direta bit por bit tarefa insana. O arquivo Pipoca.xls serve
exatamente para isto, cumprindo as funes de assembler e de micro-assembler, como
descrevemos nas prximas sees. Este arquivo contm as planilhas Microinstructions,
Microprogram, Instructions, SumX, ReadX, SearchX e Aux.
A planilha Microinstructions pode ser vista na Figura 158, e contm em cada linha um
mnemnico da micro-instruo, seu cdigo em decimal e binrio, e uma descrio. Ali tambm
pode ser vista a nica frmula utilizada, que utiliza a funo Excel DEC2BIN para converter um
nmero decimal para binrio.

Figura 158: A planilha Microinstructions

A planilha Microprogram, mostrada na Figura 159 , de longe, a mais complicada no arquivo


Pipoca.xls. As colunas onde o microprograma definido so aquelas com cabealhos de cor
palha; as colunas com cabealhos de cor cinza so campos calculados. Passamos agora a
descrever suas colunas.
Colunas Addr(HEX) e Address. A coluna Address simplesmente uma enumerao de
endereos consecutivos a serem ocupados na memria de microprograma, em decimal; a

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

90

coluna Addr(Hex) obviamente sua converso para hexadecimal, muito teis para
acompanhamento da execuo de um programa no Logisim.
Colunas Label, m-Instruction e Operand. nessas colunas que a parte de controle do
microprograma definida. Para microinstrues de sinais estes campos devem ser mantidos
vazios.
Coluna Type. Essa coluna contm 0 se a microinstruo for de controle, e 1 se for de sinais,
valor calculado por uma frmula que simplesmente verifica se a coluna m-Instruction da
mesma linha est vazia.
Colunas Signals. So os sinais que a unidade de controle deve enviar CPU quando a
microinstruo for do tipo Signal. O micro-programador deve colocar 1s nas posies
correspondentes aos sinais desejados.
Coluna mOpCode(DEC). um campo calculado que tem o valor 0 se o campo m-Instruction
estiver vazio na linha, e seno, o cdigo decimal da microinstruo obtida por pesquisa por seu
mnemnico na planilha Microinstruction.
Coluna Operand(DEC). um campo calculado que tem o valor 0 se o campo Operand estiver
vazio na linha, e seno, o valor da coluna Address na linha onde o valor na Coluna Label igual
ao campo Operand.
Colunas Bin2Dec Conversion. Estas colunas fazem a converso para decimal de cada bit nas
colunas Type e Signals, multiplicando o bit pela potncia de 2 correspondente sua posio na
microinstruo.
Coluna Microinstruction Word(DEC). Esta coluna contm o valor em decimal da palavra de 24
bits contendo a microinstruo. Para compreender sua frmula de clculo preciso examinar
o formato das microinstrues, mostrado na Figura 137.

Figura 159: A planilha MicroProgram

O valor em decimal da micro-instruo igual soma:

do campo Type multiplicado por 223

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

91

do campo OpCode(DEC) multiplicado por 219;

do campo mOperand.

das potncias de 2 correspondentes a cada sinal igual a 1 na microinstruo.

Deve-se observar que quando Type = 1, a microinstruo de controle e todos os sinais so


iguais a 0, e quando Type = 0 o campo OpCode(DEC) igual a zero, pois a microinstruo de
sinais. Nas microinstrues de controle os bits de 8 a 18 no esto sendo utilizados.
Coluna Microinstruction Word(HEX). simplesmente a converso para hexadecimal com 6
dgitos do valor decimal da microinstruo.
A planilha Instructions est mostrada na Tabela 12, na pgina 69. Alm das colunas
Description, Mnemonic, Opcode10 e Opcode2, que j comentamos, esta planilha contm a
coluna BranchTable16, que calculada pesquisando para cada mnemnico de instruo o
endereo hexadecimal da micro-instruo com label igual a este mnemnico na planilha
Microprogram. esta coluna que deve ser utilizada para a produo de uma imagem de
memria para a ROM Branch Table da Unidade de controle.
2.4.10.1 Programando a Pipoca
As planilhas SumX e ReadX do arquivo Pipoca.xls contm programas em Assembler, e
produzem imagens de memria a serem carregadas na RAM da CPU. Para explicar estas
planilhas ns vamos mostrar como se constri um novo programa.

Figura 160: O programa SearchX

O primeiro passo consiste em copiar o cabealho de um dos programas j existentes em uma


nova planilha, e ali codificar o seu programa, como mostrado na Figura 160. Aqui devem ser
Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

92

colocados tambm os tamanhos de cada instruo ou varivel todos iguais a 1 neste


programa. Depois, calcule os endereos, colocando 0 (zero) na primeira linha da coluna
Address(DEC) e, nas linhas seguintes desta coluna, a frmula que soma o endereo e o
tamanho da linha anterior para obter o endereo da linha corrente, como mostrado na Figura
161. Para obter os endereos em hexadecimal (muito teis para acompanhar a execuo do
programa, pois o Logisim mostra endereos em hexadecimal), basta usar a frmula Excel
DEC2HEX(Ci;2) para a linha i da coluna Address(HEX).

Figura 161: Clculo dos endereos - as setas destacam a clula C3 e sua frmula

Para obter o mapa de memria preciso agora colocar frmulas para calcular o valor de cada
palavra neste mapa. Para isso, copie as colunas OpCode10, Operand10, Word10 e Word16 da
primeira linha do programa SomaX, e cole somente as frmulas nas mesmas colunas da
primeira linha do seu novo programa. Depois, selecione as clulas com as frmulas no novo
programa, copie e cole nas linhas restantes nestas colunas, para obter a planilha completa
mostrada na Figura 162.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

93

Figura 162: Planilha completa com o programa SearchTable

As frmulas para as quatro colunas mais direita realizam pesquisas e clculos:

Para a coluna OpCode10 (OpCode em decimal), a frmula para a clula H2


H2 =IF(ISBLANK(E2);0;INDEX(Instructions!C$2:C$18;MATCH(E2;Instructions!B$2:B$18;0)))

que diz ao Excel para colocar 0 se o campo de cdigo de instruo (E2) estiver vazio e,
seno, efetuar uma pesquisa na coluna B da planilha Instructions procurando o cdigo
da instruo (na coluna E2), obtendo assim seu cdigo decimal, que est na coluna C
desta planilha.

Para a coluna Operand10, a frmula para a clula I2


I2 =IF(ISBLANK(G2);0;IF(ISNUMBER(G2);G2;INDEX(C$1:C$36;MATCH(G2;A$1:A$36;0);1)))

dizendo ao Excel para colocar 0 se o campo de operando (G2) estiver vazio e, seno, se
o operando for um nmero, colocar este nmero diretamente; se o operando for uma
referncia, pesquisar pelo operando na coluna de labels (A), obtendo o valor do
endereo correspondente.

Para a coluna Word10, a frmula para a clula J2


J2 = H2*2^12+F2*2^10+I2

que calcula o valor em decimal da instruo, com potncias de 2 escolhidas segundo o


posicionamento do termo na palavra de 16 bits como mostrado na Error! Reference
source not found..

Para a coluna Word16, a frmula para a clula K2


H2 = DEC2HEX(J2;4)

que converte o valor decimal para um hexadecimal com 4 dgitos.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Organizao de Computadores

94

Figura 163: Arquivo com imagem de memria para o programa SearchTable

Para obter um arquivo com o mapa de memria que pode ser lido pelo Logisim,

use o Bloco de Notas para criar um arquivo SearchTable.txt, e digite v2.0 raw em sua
primeira linha;
depois, copie todos os valores na coluna Word16 da planilha com o programa, e cole
no Bloco de Notas, a partir da segunda linha. A Figura 163 mostra a janela do Bloco de
Notas com o programa executvel.

Salve o arquivo; seu programa estar pronto para ser executado.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

95

3 Ambiente e Linguagem Scilab


3.1 Introduo ao Ambiente e Linguagem Scilab
It is felt that FORTRAN offers as convenient
a language for stating problems for machine solution
as is now known. J.W. Backus, H. Herrick e I.Ziller, 1954

Ns vimos na Seo 2.4 como programar um computador em linguagem de mquina. Ao


construir um programa, o programador deve pensar em composies de instrues que
refletem a arquitetura da mquina especfica em que est trabalhando: seus registradores,
memrias, rotas de dados. A tarefa de programar se torna extremamente detalhada e
propensa a erros. Um programa feito para um computador no pode ser executado por um
outro com um repertrio distinto de instrues.
Ns vimos tambm que o processo de montagem manual dos bits das instrues de um
programa escrito com mnemnicos pode ser feito com a ajuda de um assembler, um programa
que l outro programa escrito com mnemnicos e labels, e faz automaticamente a montagem
das instrues. Programas montadores melhoraram muito a vida dos programadores, que
antes tinham que refazer todo o processo de montagem ao ter por exemplo uma posio de
memria modificada. A montagem manual de instrues foi feita pelos primeiros
programadores, ainda na dcada de 40. Montadores foram introduzidos no incio dos anos 50.
A idia de se produzir programas que facilitam a programao foi levada adiante, e na
verdade uma idia central na cincia da computao. Em 1954 a linguagem Fortran de
Formula Translating foi proposta por um grupo de pesquisadores da IBM. com alguma
emoo que ns, cientistas da computao, vemos o fac-smile do original datilografado,
naturalmente do relatrio tcnico Preliminary Report: Specifications for the IBM
Mathematical FORmula TRANslating System, FORTRAN (I.Ziller, 1954), que pode ser
encontrado no site (McJones).
Um compilador um programa que tem como entrada um outro programa, escrito em uma
linguagem de alto nvel, e que produz um programa em linguagem de mquina para uma
arquitetura especfica. O primeiro compilador foi escrito em assembler do IBM 704, uma
mquina que tipicamente contava com 15K de memria. Desta poca at hoje j foram
desenvolvidas com maior ou menor grau de sucesso muitas linguagens milhares delas,
literalmente. Um mapa cronolgico com as principais linguagens de programao pode ser
encontrado na referncia(O'Reilly Media). Fortran uma linguagem que, tendo passado por
diversas atualizaes, at hoje muito usada por cientistas e engenheiros, e isso no deve
mudar em um futuro breve.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

96

Figura 164: Fac-smile do relatrio de especificao da linguagem FORTRAN, obtido na referncia (McJones)

Outras linguagens importantes que so sucessoras diretas de Fortran so:

Cobol, usado em aplicaes comerciais desde 1959,


a linguagem C, de 1971, que produz cdigos extremamente eficientes,
C++, sucednea de C e que orientada a objetos,
Basic, criada em 1964 e que recebeu grandes investimentos da Microsoft,
Pascal, de 1970, muito usada como primeira linguagem em cursos de programao,
Python, de 1991 que usada na plataforma de programao Google,
Java, de 1995, que certamente a linguagem que hoje em dia recebe maiores
investimentos da indstria de software, e
PHP, de 1995, que tem muitos adeptos na comunidade de software livre (o Moodle
escrito em PHP).

Existem ainda linguagens que seguem outros paradigmas de programao, como linguagens
funcionais, das quais LISP provavelmente a mais importante, e linguagens lgicas como
Prolog.
Nos fins dos anos 70 Cleve Moler inventou uma linguagem, Matlab, voltada para o tratamento
de matrizes que, em 1984, foi lanada comercialmente pela empresa MathWorks. Matlab vem
de Matrix Laboratory, e um fenmeno entre engenheiros e cientistas. O Matlab um
interpretador, isto , um programa que executa programas, por contraste com um compilador,
que traduz um programa em linguagem de alto nvel para linguagem de mquina.
Scilab, a linguagem que adotamos neste curso, desenvolvida desde 1990 por pesquisadores
do Institut Nacional de Recherche en Informatique et Automatique, o INRIA, e da cole
Nationale des Ponts et Chausses, duas instituies francesas. muito semelhante ao Matlab

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

97

e, fator essencial para sua escolha, gratuito. O Scilab tambm um interpretador, e


encontra-se atualmente na verso 5.1, lanada em fevereiro de 2009.
Do ponto de vista da cincia da computao, Matlab e Scilab no mereceriam destaque em
uma galeria de linguagens de programao. Entretanto, a facilidade que oferecem para a
construo de pequenos programas voltados para engenharia e cincia no encontra rival nas
linguagens tradicionais como Fortran, C ou Java.
Antes de entrarmos na apresentao do ambiente e da linguagem Scilab queremos colocar
algumas observaes gerais sobre linguagens de programao, que voc deve ter em mente
ao iniciar seu estudo. Uma linguagem de programao, como as linguagens naturais, une
riqueza de expresso a detalhes sintticos e algumas arbitrariedades. Detalhes e
arbitrariedades frequentemente vm de escolhas feitas no passado, incluindo algumas que j
no fazem mais sentido mas que so mantidas por uma inrcia natural. Seu aprendizado exige
uma postura paciente, pois envolve no incio uma taxa relativamente alta de memorizao.
Mas como uma linguagem natural, a fluncia vem com o uso, e com a fluncia vem a
percepo da riqueza da linguagem.
O Scilab tambm um ambiente que interpreta comandos e programas. Ele oferece uma
console para interao com o usurio, um editor para a construo de programas, o Scipad, e
tambm emite mensagens de erros relativos tanto obedincia de comandos e programas s
regras da linguagem como a problemas que podem ocorrer na execuo, como uma diviso
por zero.

Barra de
Menus
Barra de
Ferramentas

Prompt de
Comandos
Figura 165: cone e tela inicial com a console do Scilab

A Figura 165 mostra a tela obtida ao clicar sobre o cone do Scilab. uma janela simples, com
uma barra de menus e uma barra de ferramentas, e um painel central com um prompt de
comandos, indicado pela setinha --> . nesse prompt que so digitados comandos a serem
interpretados pelo Scilab. Esta janela a console do Scilab.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab


3.1.1

98

Variveis e Comandos de Atribuio

Prompt de
Comandos

a uma varivel
que passa a existir,
recebe e guarda um
valor (10, no caso)

O Scilab ecoa o
-->a = 10
valor recebido pela
a =
varivel
10.
-->b = 2^10
b =
Exponenciao
1024.
-->c = a+b
c =
O valor recebido
pode ser uma
1034.

expresso aritmtica
com variveis j
conhecidas
Figura 166: Variveis e comandos de atribuio

O principal comando que transforma informao chamado comando de atribuio. Na Figura


166 ns vemos trs comandos de atribuio simples. No primeiro deles, a = 10, a uma
varivel que passa a existir no interpretador, e que recebe e armazena um valor, no caso, 10.
Aps executar um comando de atribuio o Scilab ecoa, isto , imprime o valor recebido pela
varivel.
Variveis so nomes para espaos de memria gerenciados pelo Scilab; um programador no
precisa ter qualquer idia de como esse gerenciamento feito. Variveis tm seus nomes
escolhidos pelo programador segundo algumas regras:

O primeiro caractere do nome deve ser uma letra, ou qualquer caractere dentre '%',
'_', '#', '!', '$ e ?';
Os outros podem ser letras ou dgitos, ou qualquer caractere dentre '_', '#', '!', '$ e '?'.
Mesmo sendo francs, o Scilab no permite o uso de letras acentuadas ou de cedilhas
em nomes de variveis.

Exemplos de nomes de variveis vlidos so a, A, jose, total_de_alunos,


#funcionarios. O Scilab distingue entre maisculas e minsculas e, portanto, a e A seriam
variveis diferentes. Nomes no vlidos so 1Aluno (porque o primeiro caractere um
algarismo), total de alunos (porque tem espaos), ou jos (porque acentuado).
Um comando de atribuio tem o formato
<varivel alvo> = <expresso>
onde:

A <varivel alvo>, se no existia, passa a existir;


Se existia, o valor anterior perdido;
Na execuo do comando, a <expresso> calculada, e o resultado atribudo
<varivel alvo>.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

99

-->d = a+x
!--error 4
Undefined variable:
x
-->b = 2*b
b =
2048.
A expresso pode conter
a varivel alvo, em uma
estrutura similar a um
registrador acumulador

Todas as variveis em
uma expresso devem
estar definidas, ou o
Scilab reclama

* denota
Multiplicao
18

Figura 167: Usos e erros em comandos de atribuio

Conforme ilustrado na Figura 167, todas as variveis envolvidas na <expresso> devem ter
valores definidos no momento da execuo do comando.
Vale ainda observar que a <expresso> pode conter a <varivel alvo>, em um arranjo similar
ao utilizado nos registradores acumuladores.

-->a = %pi
a =
3.1415927
-->b = 2*%pi;

Valor prdefinido
; suprime
o eco
automtico

-->c = cos(a) + sqrt(b)


c =
O Scilab oferece um sem1.5066283
nmero de funes prdefinidas
(sqrt = square root).
Figura 168: Exemplos de comandos de atribuio com variveis com valor pr-definido, supresso de eco e
funes elementares

O Scilab oferece tambm variveis com valores pr-definidos, como %pi ou %eps, e uma
enorme variedade de funes pr-definidas (veja a Figura 169).
Um detalhe muito til a possibilidade de supresso do eco automtico, que algumas vezes
polui a tela com informao desnecessria, e que obtido com o uso de um ; colocado aps
o comando de atribuio.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

100

Figura 169: Lista de funes elementares encontrada no help do Scilab

A construo de expresses aritmticas mais elaboradas exige o conhecimento das regras de


prioridades entre operadores e o uso de parnteses para se obter o resultado desejado. Como
um exemplo, qual valor ser atribudo a uma varivel x pelo comando x = 2^3*4, o valor
, ou o valor
? A Tabela 16 mostra as prioridades
empregadas pelo Scilab no clculo de expresses. Ali vemos que a potenciao tem prioridade
sobre a multiplicao, e portanto o valor atribudo a x pelo comando acima ser
.
Tabela 16: Prioridades entre operadores em uma expresso aritmtica

Prioridade
1a
2a
3a

Operao Associatividade
Potenciao

Da direita para a
esquerda
Multiplicao, Da esquerda para a
diviso
direita
Adio,
Da esquerda para a
subtrao
direita

Se a inteno do programador era de atribuir a x o valor


, parnteses
deveriam ter sido usados no comando de atribuio como em x = 2^(3*4).

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

101

Figura 170: Prioridades e parnteses influenciando o valor de uma expresso aritmtica

Na Figura 170 ns vemos alguns exemplos de como o Scilab interpreta expresses aritmticas.
De uma forma geral, recomendvel o uso de parnteses para tornar clara a inteno do
programador.
3.1.2

Programas Scilab

Para tentar tornar clara a utilidade de um programa, vamos resolver com a console Scilab uma
equao de segundo grau, que tem a forma

Ns queremos calcular as razes para


,
sabemos que as razes so encontradas pelas frmulas

. Ns

onde
na Figura 171.

. A primeira coisa a fazer inicializar variveis a, b e c, conforme mostrado

Figura 171: Inicializao dos coeficientes de uma equao de 2o grau

Depois, calculamos

e as razes, como mostrado na Figura 172.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

102

Figura 172: Clculo das razes da equao de 2o grau

Repare que usamos variveis delta, r1 e r2, com nomes aceitveis para o Scilab e com
significado para ns. Repare tambm nas expresses usadas nos comandos de atribuio.
Erros comuns cometidos por iniciantes so:

escrever delta = b^2 4ac, omitindo os operadores de multiplicao, que


entretanto so imprescindveis para que o Scilab compreenda a expresso, ou
escrever r1 = (-b+sqrt(delta))/2*a, o que na verdade levaria ao clculo de
, o que no o que queremos.

Sempre bom verificar os resultados de um clculo ou de um programa. Para isso podemos


tambm usar o Scilab, com os comandos mostrados na Figura 173. Nesta figura voc deve
reparar:

na apario da varivel ans, que utilizada pelo Scilab para armazenar resultados de
expresses soltas, que no fazem parte de um comando de atribuio;
na notao 3.865D-12, que a forma de se escrever a constante
.

Ali vemos que o valor do polinmio da equao nas razes que calculamos no exatamente
zero. Isso no deve constituir preocupao, pois os valores so relativamente muito pequenos,
da ordem de
para r1, e
para r2. Nmeros no Scilab so armazenados como
ponto flutuante de 64 bits (veja a Seo 2.1), onde as operaes podem envolver
arredondamentos.

Figura 173: Verificando os resultados

Muito bem, conseguimos usar o Scilab para resolver uma equao de 2 grau, o que no chega
a ser uma faanha. Mas tivemos ganhos com relao execuo dos mesmos clculos com
uma calculadora de mo:

o uso de variveis evita re-digitaes e possveis erros;


resultados intermedirios so memorizados e podem ser reaproveitados;
o uso de frmulas como na Figura 172 aumenta muito a confiana nos clculos.

As limitaes do uso direto da console Scilab para clculos tornam-se claras quando queremos
resolver outra equao de 2 grau. Frmulas tm que ser re-digitadas, abrindo uma ocasio
para erros, com pouco aproveitamento do trabalho j feito. A soluo para isso usar o Scilab
como um interpretador de programas.
Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

103

Um programa fonte Scilab um arquivo ASCII, isto , um arquivo que s contm textos sem
formatao, e que tem a terminao .sce. Um arquivo-programa contm comandos Scilab, e
construdo usando o editor SciPad (veja na Figura 174 como o editor aberto no Scilab 5.1).
A execuo (interpretao) de um programa se faz seguindo o menu File/Execute da console
do Scilab; essa execuo equivale digitao na console dos comandos presentes no arquivo.

Figura 174: Abrindo o editor SciPad

Ateno: nunca use o Word ou qualquer outro editor de textos sofisticado para abrir e/ou
editar arquivos de programas. Esses editores podem introduzir bytes de informao de
formatao, o que perturba completamente a interpretao do programa pelo Scilab.
No editor Scipad voc pode:

Criar um novo programa, atravs do menu File/New;


Abrir para edio um programa j existente, atravs do menu File/Open
Editar um programa
Salvar o programa editado, atravs do menu File/Save
Executar um programa, atravs do menu Execute/Load into Scilab

e vrias outras coisas que voc ir aprendendo aos poucos.


O Scilab trabalha com um diretrio corrente, que a primeira opo de localizao para
procurar e para salvar arquivos. Na console do Scilab voc pode escolher o diretrio corrente
atravs do menu File/Change current directory. O diretrio corrente do Scipad o diretrio
corrente do Scilab no momento em que o editor aberto.
Um conselho: organize os seus arquivos! Perde-se muito tempo procurando arquivos gravados
no se lembra aonde. O autor destas linhas cria um diretrio para cada semana, onde so
colocados todos os arquivos que so utilizados; voc pode adotar uma organizao similar em
seu computador pessoal. Ao usar computadores compartilhados, crie um diretrio de trabalho
com o seu nome, o que ir facilitar a sua limpeza posterior.

// indica que a
linha um
comentrio

Figura 175: O SciPad editando o programa Eq2g1.sce

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

104

A Figura 175 mostra um programa que tem em cada linha exatamente os mesmos comandos
que utilizamos na console para resolver a equao de 2 grau. Ns demos a este programa o
nome Eq2g1.sce; usamos um nmero no nome do arquivo porque faremos outras verses
deste mesmo programa. Se voc rodar este programa, usando o menu File/Execute, voc
obter os mesmos resultados que conseguimos com a console.
As duas primeiras linhas do programa Eq2g1.sce se iniciam por //, o que faz com que sejam
ignoradas pelo Scilab no momento da execuo. Essas linhas so comentrios, e tm o
importantssimo objetivo de melhorar a compreenso de um programa por um leitor humano.
Com um programa gravado em um arquivo, se quisermos resolver uma nova equao, bastar
substituir no programa os valores dos novos coeficientes e execut-lo novamente.
Comparando com o processo de resoluo via console, o uso de um programa reduz
consideravelmente as chances de erros de digitao.
Entretanto, a prtica de se alterar programas para introduzir dados que se modificam a cada
execuo no recomendvel, e nem exeqvel quando o volume de dados muito grande. O
melhor a fazer modificar o programa para permitir que o usurio defina os valores dos
coeficientes a cada execuo.

Figura 176: O programa Eq2g2.sce com os comandos de dilogo em destaque

O comando input permite essa interao com o usurio. Como vemos na Figura 176, este
comando recebe como parmetro uma frase a ser exibida para o usurio, que normalmente
usada para descrever o valor a ser digitado.

Figura 177: Execuo do programa Eq2g2.sce

A Figura 177 mostra a console do Scilab em uma execuo do programa Eq2g2.sce, onde voc
pode verificar o efeito da execuo dos comandos input. Os valores digitados pelo usurio
Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

105

para os coeficientes a, b e c foram, respectivamente, 1, 2 e 3. Estes valores levam a um


negativo, e o exemplo serve tambm para ilustrar a naturalidade com que o Scilab trata
nmeros complexos.
Para enriquecer nosso repertrio de comandos Scilab, vamos agora construir um terceiro
programa que resolve equaes do 2 grau, mas com as seguintes alteraes na especificao:

o programa s dever calcular as razes quando elas forem reais;


a sada do programa dever ser uma frase como As razes so xxxx e xxxx, quando as
razes forem reais, e seno, As razes so complexas.
// Clculo das razes de uma equao
// de 2o grau
a = input("Digite o valor de a:");
b = input("Digite o valor de b:");
c = input("Digite o valor de c:");
delta = b^2 - 4*a*c
if delta >= 0 then
r1 = (-b+sqrt(delta))/(2*a);
r2 = (-b-sqrt(delta))/(2*a);
printf("As razes so %g e %g",r1,r2)
else
printf("As razes so complexas")
end
Figura 178: O programa Eq2g3.sce

A Figura 178 mostra o programa Eq2g3.sce, que atende a essas especificaes. Este programa
introduz dois novos comandos: if, e printf. Repare que terminamos com ; aps vrios
dos comandos de atribuio, o que suprime o eco automtico e torna a sada mais limpa.
if <condio> then
<bloco ento>
else
<bloco seno>
end
Figura 179: O comando if

O comando if usado para prescrever comportamentos condicionais na execuo do


programa. Sua forma geral est mostrada na Figura 179, onde:

if, then, else e end so as palavras-chave que o Scilab usa para reconhecer o
comando;
if marca o incio do comando;
<condio> uma expresso lgica, tipicamente uma comparao entre
expresses aritmticas, cujo valor avaliado como verdadeiro ou falso;
then separa a <condio> do <bloco ento>;
<bloco ento> e <bloco seno> so conjuntos arbitrrios de comandos
Scilab;
else marca o fim do <bloco ento> e o incio do <bloco seno>;
end a palavra-chave que fecha o comando if.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

106

na execuo do comando if, o <bloco ento> executado se e somente se a


<condio> for verdadeira, e o <bloco seno> executado se e somente se
a <condio> for falsa.

Em alguns casos no desejamos executar nenhum comando no caso da <condio> ser


falsa, e o comando pode assumir uma forma simplificada, sem a clusula else, como mostrado
na Figura 180.
if <condio> then
<bloco ento>
else
// Nenhum comando aqui
end

if <condio> then
<bloco ento>
end

Figura 180: Duas formas equivalentes do comando if, a da direita sem a clusula else

A Figura 181 mostra os blocos de comandos e a condio do comando if do programa


Eq2g3.sce.

<condio>

<bloco ento>

if delta >= 0 then


r1 = (-b+sqrt(delta))/(2*a)
r2 = (-b-sqrt(delta))/(2*a)
printf("As razes so %g e %g",r1,r2)
else
printf("As razes so complexas")
end
<bloco seno>
Figura 181 :Partes do comando if do programa Eq2g3.sce

Expresses lgicas normalmente fazem uso de operadores relacionais para comparar valores
de duas expresses. A Tabela 17 mostra os operadores relacionais usados no Scilab, onde
voc pode reparar que igual a representado por dois = consecutivos, uma herana da
linguagem C, e que existem duas formas de representao de diferente de.
Tabela 17: Operadores relacionais

>
>=
<
<=
==
<> ou ~=

maior que
maior ou igual a
menor que
menor ou igual a
igual a
diferente de

O comando printf tem a forma


printf(<frase>,<lista de expresses>)
onde

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

107

<frase> a sentena que se quer imprimir na tela, e que pode estar entremeada
por cdigos de formato como %g; %g um cdigo de formato geral para expresses
com valores numricos (ns veremos em seguida expresses com outros tipos de
valores); existem vrios outros cdigos de formato como %d, %f ou %s, que iremos
explorar em exerccios e em outros exemplos neste texto.
<lista de expresses> uma lista de expresses separadas por vrgulas, que
so calculadas no momento da execuo do comando;
as expresses na lista so mapeadas uma a uma nos cdigos de formato, na mesma
sequncia em que aparecem na <frase>, e a sentena impressa obtida pela
substituio do valor da expresso na posio marcada pelo cdigo de formato.

No comando printf("As razes so %g e %g",r1,r2)as duas expresses na lista


so muito simples, formadas por uma varivel. A expresso r1 mapeada no primeiro %g, e a
expresso r2 mapeada no segundo %g. A Figura 182 mostra uma sada do programa
Eq2g3.sce onde se pode ver o efeito da execuo deste comando.
Digite o valor de a:3
Digite o valor de b:4
Digite o valor de c:1
delta =
4.
r1 =
- 0.3333333
r2 =
- 1.
As razes so -0.333333 e -1
Figura 182: Uma sada do programa Eq2g3.sce

Obs. No Scilab 5.1.1 existe um bug que no permite o uso de caracteres acentuados ou cedilhas
na <frase> do comando printf.
3.1.3

Loops: os comandos for e while

Vamos agora atacar um outro problema: o clculo do fatorial de um nmero a ser lido em
tempo de execuo. O Scilab oferece diretamente a funo factorial(n), que j faz este
clculo, mas aqui ns estamos interessados em programar esta funo.
Ns sabemos que
, e que portanto teremos que realizar repetidas
multiplicaes para obter o fatorial. Este comportamento pode ser obtido com o uso do
comando for, que prescreve um loop, ou seja, uma repetio de comandos. A execuo do
comando
for j = 1:5
<bloco for>
end
resulta em 5 execues do bloco de comandos <bloco for> . Na primeira execuo, a
varivel j recebe o valor 1; na segunda, o valor 2, e assim por diante, at a ltima execuo,
onde j recebe o valor 5.
Muito bem, j temos condies de compreender o programa Fatorial1.sce, mostrado na Figura
183. Repare no uso no printf do cdigo de formato %d, apropriado para a converso de
variveis com valores inteiros.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

108

// Clculo do fatorial de n
// Leitura de n
n = input("Valor de n = ");
// Clculo do fatorial
fat = 1;
for i=1:n
fat = fat*i;
end
// Impresso do resultado
printf("O fatorial de %d %d",n,fat);
Figura 183: Programa Fatorial1.sce

Mas a parte central do programa o loop destacado em vermelho na figura. A varivel fat
inicializada com o valor 1. Na primeira passagem pelo loop, i igual a 1, e fat recebe o
valor 1*1. Na segunda passagem i igual a 2, e fat recebe o valor 1*2, igual a 2; na terceira
passagem, fat recebe o valor 2*3, igual a 6; na quarta passagem, o valor 6*4, igual a 24; na
quinta, 24*5, e assim por diante. Ou seja, pelo fato de a cada passagem fat receber como
valor seu valor anterior multiplicado por i, na i-sima execuo do corpo do for, fat passa
a conter o fatorial de i. Como o loop termina com i igual a n, o valor de fat na sada do loop
o fatorial de n.
Tabela 18: Tabela de Senos

x
0.0
0.2
0.4
0.6
0.8

seno(x)
0.0000
0.1987
0.3894
0.5646
0.8415

Vamos agora usar o comando for para a construo de uma tabela como a Tabela 18, com x
variando de 0 a
, de 0.2 em 0.2. Antes porm vamos aprender mais sobre o comando for,
cuja forma geral est mostrada na Figura 184
for <varivel> = <inicial>:<passo>:<limite>
<bloco for>;
end
Figura 184: Forma geral de um comando for

Aqui <inicial>, <passo> e <limite> so expresses que controlam os valores


atribudos varivel indexadora <varivel> a cada iterao do loop, e tambm a condio
de parada do loop.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

109

for i = 1:2:10
printf('\ni = %g',i);
end
i
i
i
i
i

=
=
=
=
=

1
3
5
7
9

i varia de 2 em 2
Sada

Repare que i no assumiu o


limite superior do loop
Figura 185: Exemplo de comando for com passo diferente de 1

No exemplo da Figura 185,

A varivel indexadora i, que assume o valor <inicial> 1 na primeira iterao do


loop;
A o fim de cada iterao soma-se 2 (o <passo>) varivel indexadora, ou seja, i
assume os valores 1, 3, 5, ...;
Tambm ao fim de cada iterao o novo valor da varivel indexadora comparado
com o <limite> , e o loop termina quando o valor da varivel indexadora tiver
ultrapassado o <limite>. No caso, o loop termina quando i tiver o valor 11, que
ultrapassa o limite 10.
O \n na frase do comando printf um caractere especial, que produz uma nova
linha na sada.

for i = 20:-2:16
printf('\ni = %g',i);
end
i = 20
i = 18
i = 16

Sada

Figura 186: Exemplo de for com passo negativo

O <passo> de um for pode ser negativo, como mostrado na Figura 186, e a varivel de
controle pode assumir valores no inteiros, como na Figura 187.
A varivel de controle
pode assumir valores
no inteiros

for x = 0:0.3:0.7
printf('\nx = %g',x);
end

x = 0
x = 0.3
x = 0.6

Sada

Figura 187: Exemplo de for com a varivel de controle assumindo valores no inteiros

Com este ltimo exemplo a construo da tabela de senos fica simples.


Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

110

// Tabela da funo Seno


for x = 0:0.2:2*%pi
printf("%g %g",x, sin(x))
end
Figura 188: O programa Tabela_de_Senos_1.sce

O programa da Figura 188 parece atender especificao, mas quando executado pelo Scilab
produz uma sada de difcil compreenso, como mostrado na Figura 189.
-->
0 00.2 0.1986690.4 0.3894180.6 0.5646420.8 0.7173561 0.841471
Figura 189: Primeiros caracteres da sada do programa Tabela_de_Senos_1.sce

Um primeiro problema a corrigir a separao em linhas, o que pode ser obtido usando o
smbolo \n na frase do comando printf. Com isso ns chegamos ao programa
Tabela_de_Senos_2.sce, mostrado na Figura 190.
// Tabela da funo Seno
for x = 0:0.2:2*%pi
printf("\n%g %g",x, sin(x))
end
Figura 190: O programa Tabela_de_Senos_2.sce

A sada do Tabela_de_Senos_2.sce, cujas primeiras linhas esto mostradas na Figura 191,


melhorou, mas ainda no est satisfatria.
0 0
0.2 0.198669
0.4 0.389418
0.6 0.564642
0.8 0.717356
1 0.841471
1.2 0.932039
Figura 191: Sada do programa Tabela_de_Senos_2.sce

Os problemas de alinhamento so causados pelo uso do cdigo de formato %g, que no


especifica o nmero de colunas (que igual ao nmero de caracteres com a fonte tipogrfica
no proporcional usada pelo Scilab, onde todas as letras ocupam o mesmo espao. Com uma
fonte proporcional, como esta que voc est lendo, um i ocupa um espao menor do que um
m, o que bem visvel quando comparamos iiii com mmmm) que um nmero ir ocupar e que,
tentando agradar, no imprime casas decimais quando o nmero a ser impresso inteiro.
// Tabela da funo Seno
// Impresso do cabealho
printf("\n x
seno(x)")
// Impresso das linhas da tabela
for x = 0:0.2:2*%pi
printf("\n%3.1f %7.4f",x, sin(x))
end
Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

111

Figura 192: O programa Tabela_de_Senos_3.sce

A Figura 192 mostra o programa Tabela_de_Senos_3.sce que produz a sada mostrada


parcialmente na Figura 193.
x
0.0
0.2
0.4
0.6
0.8
1.0
1.2

seno(x)
0.0000
0.1987
0.3894
0.5646
0.7174
0.8415
0.9320

Figura 193: Primeiras linhas da sada do programa Tabela_de_Senos_3.sce

Nessa ltima verso,

impressa uma linha com cabealhos para a tabela


Para a formatao de x usado o cdigo %3.1f, que especifica um campo ocupando
3 colunas ao todo na impresso, com 1 casa decimal;
Para a formatao de sin(x), o cdigo %7.4f especifica um campo com um total de
7 colunas, com 4 casas decimais.

O comando for , na verdade, um caso particular de outro comando repetitivo, o comando


while , cuja forma est mostrada na Figura 194.
while <condio>
<bloco while>
end
Figura 194: O comando while

Nesse comando:

<condio> uma expresso lgica; o loop s termina quando essa expresso for
avaliada para falso.
<bloco while> um bloco de comandos.

Todo comando for pode ser substitudo por um comando while; a Figura 195 mostra um
exemplo dessa substituio.

for x = 0:0.2:2*%pi
printf("\n%3.1f %7.4f",...
x, sin(x))
end

x = 0;
while x <= 2*%pi
printf("\n%3.1f %7.4f",...
x, sin(x))
x = x+0.2;
end

Figura 195: Mesmo loop obtido com comandos for e while

O emprego do comando while deve ser feito com ateno, pois voc pode prescrever um
loop que nunca ir parar, como no exemplo da Figura 196. O while s ser interrompido
quando x for maior que 10, o que nunca acontecer porque x vale 0 inicialmente, e a cada
passo, fica ainda menor.
x = 0;
Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

112

while x <= 10
printf("\nx = %g", x)
x = x - 0.2;
end
Figura 196: Um loop infinito

No Scilab voc pode interromper um programa em loop infinito atravs do menu


Control/Abort. Ns veremos a seguir diversos exemplos de utilizao do comando while.
3.1.4

Valores Lgicos e Strings

Uma varivel Scilab pode armazenar tambm valores lgicos correspondentes a verdadeiro e
falso, denotados pelas constantes Scilab %t e %f (true e false), ou %T e %F. A Figura 197
mostra um exemplo de atribuio de valores lgicos a variveis usando a console do Scilab.
-->a = 7>5
a =
T
-->b = 3 ~= 10-7
b =
F
-->c = 3 == 10-7
c =
T
Figura 197: Atribuico de valores lgicos a variveis na console do Scilab

Variveis com valores lgicos podem ser parte de expresses lgicas, que usam os operadores
lgicos ~ (NOT), & (AND) e | (OR), definidos, como voc pode esperar, exatamente como na
Tabela 9 (pgina 27).
-->a = %t; b = %f;
-->~a
ans =
F
-->a & b
ans =
F
-->a | b
ans =
T
Figura 198: Exemplos de uso dos operadores lgicos ~ (not), & (and) e | (or) na console do Scilab

Alm de valores lgicos, variveis Scilab podem armazenar dados no numricos. Na Figura
199 ns vemos exemplos de como atribuir sequncias de caracteres o termo usado em
ingls, strings a variveis.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

113

-->a = "Programao"
a =
Programao
Aspas simples (') e duplas
-->b = " de '
(") so equivalentes
b =
de
-->c = "Computadores"
c =
Computadores
Figura 199: Atribuindo strings a variveis

Strings so escritos entre aspas, simples ou duplas. Voc pode mesmo iniciar um string com
aspas duplas e termin-lo com aspas simples.
Para strings, + significa
concatenao

-->a = 'Programao';
-->b = ' de ';
-->c = 'Computadores';
-->Disciplina = a + b + c
Disciplina =
Programao de Computadores
Figura 200: Concatenao de strings

Uma operao comum com strings a concatenao, que consiste na justaposio de dois
strings. No Scilab a concatenao utiliza o mesmo smbolo da adio numrica, o +.

Fim do string?
-->x = 'String "com aspas"'
!--error 276
Missing operator, comma, or semicolon

Figura 201: Erro ao tentar representar um string contendo aspas

Aspas so usadas para marcar o incio e o fim de strings, e isto pode provocar um problema ao
se tentar representar strings que contm aspas, como mostrado na Figura 201. Para isso, basta
colocar duas aspas consecutivas na posio desejada, como na Figura 202.
-->x = 'String ""com aspas duplas""'
x =
String "com aspas duplas"
-->x = 'String ''com aspas simples'''
x =
String 'com aspas simples'
Figura 202: Strings contendo aspas

Strings formadas por algarismos no so nmeros para o Scilab. O string '3.1415926' na


verdade armazenado como uma sequncia dos caracteres ASCII 3, ., 1, 4, etc., e no
como um nmero de ponto flutuante, como mostrado na Figura 38. Se tentarmos realizar
operaes aritmticas com strings de algarismos, o Scilab ir emitir uma mensagem de erro
apropriada:
Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

114

-->2*'3.1415926'
!error 144
Undefiled operation for the given operands
Figura 203: Strings formados por algarismos no so nmeros para o Scilab

Strings tambm podem ser lidos pelo comando input, como no exemplo Nome =
input("Seu nome, por favor"). Escrevendo dessa forma o comando input o
usurio deve digitar o string entre aspas. possvel eliminar a necessidade de escrita do string
entre aspas usando o comando input com um parmetro extra, um string com o valor
"string", como no comando input("Seu nome, por favor","string").
-->Nome =
Seu nome:
Undefined
Seu nome:
Nome =
Jose

input("Seu nome: ")


Jose
variable: Jose
"Jose"

-->Nome = input("Seu nome: ","string")


Seu nome: Jose
Nome =
Jose
Figura 204: Exemplos de uso do comando input na console do Scilab

Obs.:No Scilab 5.1.1 h um bug que impede a leitura de strings com caracteres acentuados ou
cedilhas.
Vamos agora exercitar nossas novas habilidades fazendo um programa que:

Leia o nome do aluno, que responde, por exemplo, Jos;


Leia tambm o total de pontos obtidos pelo aluno;
Imprima, conforme o caso, a frase <aluno>, com <pontos> voc passou!, ou ento,
caso o aluno no tenha obtido um mnimo de 60 pontos, a frase <aluno>, com
<pontos> voc no passou! Exemplos seriam Jos, com 80 pontos voc passou!, ou
Jos, com 40 pontos voc no passou!

// Leitura do nome do aluno


Nome = input("Seu nome, por favor:");
// Leitura dos pontos obtidos
Pontos = input(Nome + ", quantos pontos voc conseguiu?");
// Deciso e impresso do resultado
if Pontos >= 60 then
printf("%s, com %g pontos voc passou!",Nome,Pontos);
else
printf("%s, com %g pontos voc no passou!",Nome,Pontos);
end
Figura 205: O programa PassouNaoPassou.sce

A Figura 205 mostra o programa PassouNaoPassou.sce que atende a esta especificao.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

115

Seu nome, por favor:"Maria"


Maria, quantos pontos voc conseguiu?90
Maria, com 90 pontos voc passou!
Seu nome, por favor:"Jose"
Jose, quantos pontos voc conseguiu?47
Jose, com 47 pontos voc no passou!
Figura 206: Duas execues do programa PassouNaoPassou.sce

Dois exemplos de execues deste programa esto na Figura 206. Neste programa
importante observar:

A frase utilizada no comando input para a varivel Pontos o resultado de uma


operao de concatenao (+);
Os comandos printf utilizam o cdigo de converso %s, apropriado para strings.

Estes dois truques so exemplos de manipulao de strings que podem tornar mais simptica a
interao de um programa com seu usurio.
Um programa como o Eq2g3.sce ( Figura 178) , que resolve uma nica equao de 2 grau a
cada execuo, se torna mais til se passar a resolver tantas equaes quantas o usurio
queira. Uma estrutura simples para esta repetio controlada pelo usurio pode ser obtida
usando uma varivel lgica para controlar um loop while, conforme o modelo mostrado na
Figura 207.
continua = %t;
while continua
// Processamento de um item
printf("Item processado")
// Deciso de continuao pelo usurio
decisao = input("Continua? (s/n)","string");
continua = decisao == "s";
end
printf("Obrigado por usar nosso programa!")
Figura 207: Estrutura para repetio controlada pelo usurio

A cada passagem do loop, o usurio interrogado sobre o seu desejo de continuar, o que ele
pode expressar entrando com o caractere s, de sim. Se ele entrar com o caractere n (na
verdade, com qualquer string diferente de s), o loop interrompido e o programa termina.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

116

// Clculo das razes


// de 2o grau
continua = %t;
while continua
// Processamento de
a = input("Digite o
b = input("Digite o
c = input("Digite o

de diversas equaes

uma equao
valor de a:");
valor de b:");
valor de c:");

delta = b^2 - 4*a*c


if delta >= 0 then
r1 = (-b+sqrt(delta))/(2*a)
r2 = (-b-sqrt(delta))/(2*a)
printf("As razes so %g e %g",r1,r2)
else
printf("As razes so complexas")
end
// Deciso de continuao pelo usurio
decisao = input("Outra equao? (s/n)","string");
continua = decisao == "s";
end
printf("Obrigado, e volte sempre.")
Figura 208: O programa Eq2g4.sce, que calcula razes de diversas equaes de 2o grau

A Figura 208 mostra o programa Eq2g4.sce, que resulta da aplicao deste padro sobre o
programa Eq2g3.sce. O menu Edit/Indent Selection do editor Scipad muito til para indentar
um bloco de comandos selecionados.
3.1.5

Comandos Aninhados

Blocos de comandos definidos por comandos como if e for podem conter qualquer tipo de
comando, incluindo comandos de atribuio, de entrada e/ou sada, mas tambm outros ifs
e outros for. Este aninhamento de comandos proporciona uma grande flexibilidade para o
programador.
Para ilustrar o uso de ifs aninhados vamos agora desenvolver um programa que:

Leia o nome do aluno, que responde, por exemplo, Paulo;


Leia tambm o total de pontos obtidos pelo aluno;
Imprima, conforme o caso, a frase <aluno>, com <pontos> voc obteve o conceito X!,
onde X determinado pela Tabela 19. Exemplos seriam Paulo, com 81 pontos voc
obteve o conceitoB!, ou Paulo, com 90 pontos voc obteve o conceito A!
Tabela 19: Pontos e Conceitos

Pontos

Conceito
A
B
C
D
E
F

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

117

O programa PontosConceito.sce, apresentado na Figura 209, atende a esta especificao,


acrescida da suposio de que o usurio ir digitar sempre valores entre 0 e 100.
Neste programa voc deve observar que:

A leitura do nome e dos pontos do aluno idntica utilizada no programa


PassouNaoPassou.sce;
Se o <bloco seno> do primeiro if chegar a ser executado, porque temos
Pontos < 90, e por isto basta verificar que Pontos >= 80 para concluir que o
conceito B;
Se o <bloco seno> do segundo if chegar a ser executado, porque temos Pontos <
80, e por isso basta verificar que Pontos >= 70 para concluir que o conceito C;
O mesmo raciocnio se aplica aos outros ifs, at o mais interno, onde o <bloco
seno> no necessita de mais testes para concluir que o conceito F.
Detalhe, mas muito til: o printf no fim do programa ilustra o uso de ... para
indicar ao Scilab que um comando se prolonga por mais uma linha.

// Leitura do nome do aluno


Nome = input("Seu nome, por favor:");
// Leitura dos pontos obtidos
Pontos = input(Nome + ", quantos pontos voc conseguiu?");
// Determinao do conceito
if Pontos >= 90 then
Conceito = "A";
else
if Pontos >= 80 then
Conceito = "B";
else
if Pontos >= 70 then
Conceito = "C";
else
if Pontos >= 60 then
Conceito = "D";
else
if Pontos >= 40 then
Conceito = "E"
else
Conceito = "F"
end
end
end
end
end
printf("%s, com %g pontos voc obteve o conceito %s!",...
Nome, Pontos, Conceito)
Figura 209: O programa PontosConceito.sce

Como j dissemos e continuaremos a dizer ao longo desse curso, programas so feitos para
serem executados por computadores, mas tambm para serem lidos por humanos. Ao fazer
um programa voc deve se preocupar com a sua legibilidade, tanto por outras pessoas que
venham a trabalhar com ele, como com voc mesmo, algum tempo depois de t-lo escrito.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

118

A disposio grfica dos comandos em um programa tem grande influncia em sua


legibilidade.Talvez voc j tenha reparado que os blocos nos comandos if e for sempre
apaream ligeiramente deslocados para a direita, com relao posio do comando que os
delimita. Isso porque, com esse deslocamento, a identificao do comeo e do fim de cada
bloco fica muito facilitada, e os possveis fluxos de execuo se tornam mais claros para ns.

if delta < 0 then


printf('Razes complexas!');
else
r1 = (-b + sqrt(delta))/(2*a);
r2 = (-b - sqrt(delta))/(2*a);
printf('r1=%g e r2=%g.',r1,r2)
end

if delta < 0 then


printf('Razes complexas!');
else
r1 = (-b + sqrt(delta))/(2*a);
r2 = (-b - sqrt(delta))/(2*a);
printf('r1=%g e r2=%g.',r1,r2)
end

Mais legvel

Menos legvel

Figura 210: Ifs equivalentes para o Scilab, mas com diferenas de legibilidade devido indentao

Indentao o termo empregado para esta tcnica de deslocamento de blocos internos na


disposio grfica de um programa. Seu emprego visto como absolutamente essencial por
toda a indstria de desenvolvimento de software. A Figura 210 e a Figura 211 mostram
comparaes entre comandos digitados com e sem o emprego de indentao.

if Nota >= 90 then


Conceito = 'A';
else
if Nota >= 80 then
Conceito = 'B';
else
if Nota >= 70 then
Conceito = 'C';
else
if Nota >= 60 then
Conceito = 'D';
else
if Nota >= 40 then
Conceito = E';
else
Conceito = F;
end
end
end
end
end

if Nota >=
Conceito =
else
if Nota >=
Conceito =
else
if Nota >=
Conceito =
else
if Nota >=
Conceito =
else
if Nota >=
Conceito =
else
Conceito =
end
end
end
end
end

90 then
'A';
80 then
'B';
70 then
'C';
60 then
'D';

40 then
E';
F;

Figura 211: Outro exemplo da influncia da indentao na legibilidade de um comando

Vamos agora desenvolver um programa que produza uma tabuada de multiplicao, como
mostrado na Figura 212.
Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

119
1
2
3
4
5
6
7
8
9

2
4
6
8
10
12
14
16
18

3
6
9
12
15
18
21
24
27

4
8
12
16
20
24
28
32
36

5
10
15
20
25
30
35
40
45

6
12
18
24
30
36
42
48
54

7
14
21
28
35
42
49
56
63

8
16
24
32
40
48
56
64
72

9
18
27
36
45
54
63
72
81

Figura 212: Tabuada de Multiplicao

Um problema como este se resolve com dois for aninhados: um externo, para as linhas, e um
interno, para as colunas de cada linha, o que feito pelo programa Tabuada1.sce, mostrado na
Figura 213.
// Tabuada de multiplicao
for linha = 1:9
for coluna = 1:9
printf("%g",linha*coluna);
end
end
Figura 213: O programa Tabuada1.sce

Ao executar este programa verificamos entretanto que sua sada est ininteligvel:
12345678924681012141618369121518212...
formando uma longa sequncia de algarismos sem separao, todos em uma nica linha. O
que houve? Esquecemos de orientar o Scilab para mudar de linha, e tambm para, dentro de
cada linha, separar cada coluna.
// Tabuada de multiplicao
for linha = 1:9
for coluna = 1:9
printf("%3g",linha*coluna);
end
printf("\n");
end
Figura 214: O programa Tabuada2.sce

O programa Tabuada2.sce resolve estes problemas, com a insero de um printf("\n"),


executado ao trmino da impresso de cada linha, e com o cdigo de formato %3g que fixa 3
colunas para a impresso de cada produto.
3.1.6

Arquivos

Arquivos so unidades de armazenamento de dados no-volteis, que sistemas operacionais


como Windows ou Linux permitem que sejam recuperados pelo nome e pela posio em uma
organizao hierrquica de diretrios. Um arquivo criado por um programa, e pode ser lido e
modificado por outros programas, programas que muitas vezes so executados em outros
computadores.
Existem muitos tipos de arquivos que podem ser manipulados por programas Scilab, mas neste
curso iremos aprender somente a trabalhar com arquivos ASCII, isto , arquivos que
Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

120

normalmente so legveis por humanos, e que podem ser editados usando programas como o
Bloco de Notas do Windows.
Comandos bsicos para uso de arquivos no Scilab so:

uigetfile, que permite ao usurio selecionar um arquivo navegando nos diretrios


do sistema operacional;
mopen e mclose ,necessrios para iniciar e para terminar a manipulao de um
arquivo por um programa Scilab;
mfscanf e mfprintf , usados para ler e para gravar valores de variveis em
arquivos abertos;
meof , que permite testar se o fim de um arquivo (eof vem de end of file) j foi
atingido.

A Figura 215 mostra a janela de navegao para escolha de um arquivo aberta no Windows
Vista aps a execuo de um comando uigetfile.

Figura 215: O comando uigetfile

O comando uigetfile retorna um string com a rota completa isto , desde o diretrio raiz
do arquivo escolhido. Isso pode resultar em strings longos como o atribudo varivel f na
Figura 216.
-->f = uigetfile(title="Escolha um arquivo:")
f =
C:\Users\Osvaldo\Documents\dcc\Ensino\dcc001\Scilab\Dados\ConstrCivil.txt
Figura 216: String com rota completa obtido com uigetfile

O string obtido pode ser usado para abrir (com mopen) o arquivo correspondente. O nome de
arquivo escolhido pode ser novo ou j existir no sistema de arquivos do operacional.
Outras formas de uso do comando uigetfile so:

Arq = uigetfile()
o Mais simples, sem ttulo na janela de escolha do arquivo;
Arq = uigetfile("*.txt",pwd(),"Escolha um arquivo")

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab


o
o
o
o

121

Um pouco mais complicado, porm pode oferecer mais conforto para o


usurio, pois:
S so mostrados os arquivos selecionados por um filtro; no caso, o filtro
"*.txt", que seleciona somente arquivos com terminao .txt, e
a janela de escolha do arquivo tem o ttulo "Escolha um arquivo" ,
e exibe inicialmente o diretrio corrente do Scilab, o que pode evitar um
aborrecido trabalho de navegao na estrutura de diretrios. A funo pwd()
retorna o diretrio corrente do Scilab.

Para entender a necessidade de abertura e de fechamento de arquivos preciso saber que um


arquivo fora de uso est totalmente armazenado em uma memria no voltil, como um disco
ou um pen drive. Quando em uso, um arquivo tem parte de sua informao em disco,
digamos, e parte na memria principal. A abertura de um arquivo traz para a memria
principal informaes necessrias para o seu uso, que so atualizadas a cada operao de
escrita ou leitura no arquivo, e que por diversas razes nem sempre so imediatamente
gravadas na memria no voltil. O fechamento de um arquivo grava na memria no voltil
todas as informaes presentes na memria principal.

Varivel passa a conter um descritor de


arquivo, a ser usado posteriormente para
ler, escrever ou fechar o arquivo

da = mopen(NomeCompletoDoArquivo, r)

Varivel contendo
string, muitas
vezes obtido por
xgetfile

Modo de uso do
arquivo:
r leitura
w - escrita

Figura 217: Uso do comando mopen

Ns vemos na Figura 217 um exemplo de uso do comando mopen, que:

recebe como parmetros


o um string com o nome completo do arquivo, muitas vezes obtido com o
comando uigetfile, e
o o string r ou o string w, que indicam se o arquivo ser utilizado para leitura
(r de read) ou para escrita (w de write)
se bem sucedido, retorna um descritor de arquivo, um inteiro pequeno que ser
utilizado nas operaes de leitura e de escrita.

Um arquivo aberto pode e deve ser fechado ao trmino de sua utilizao, atravs do comando
mclose(da) , onde da o descritor do arquivo obtido no momento de sua abertura.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

122

Varivel que recebe o


nmero de variveis
efetivamente lidas em
uma linha do arquivo

String com cdigos


similares aos usados em
printf

[n,<lista de variveis>] = mfscanf(da,formato)


Descritor do
arquivo obtido
por mopen
Figura 218: O comando mfscanf

A leitura de dados em um arquivo feita pelo comando mfscanf, cuja forma est mostrada
na Figura 218. A cada execuo so lidos dados em uma linha do arquivo. Como um exemplo
de sua utilizao, considere o comando
[n,a,b,c] = mfscanf(da,"%g %g %g")
aplicado a um arquivo com os dados mostrados abaixo.
8
7
5
7

32
-21
25
-63

-40
14
0
0

Este comando faz n = 3, a = 8, b = 32 e c = -40 em sua primeira execuo, n = 3,


a = 7, b = -21 e c = 14 na segunda execuo, e assim por diante.

String com cdigos


similares aos usados em
printf

mfprintf(da, formato, <lista de variveis>)

Descritor do
arquivo obtido
por mopen
Figura 219: O comando mfprintf

O comando mfprintf bastante similar ao nosso conhecido printf, mas, por ser aplicado
a arquivos, exige como parmetro extra um descritor de arquivo aberto, como mostrado na
Figura 219.
Para ilustrar o uso de arquivos vamos retornar s equaes de 2 grau, mas agora vamos obter
os coeficientes das equaes em um arquivo de entrada, onde cada linha contm os
coeficientes de uma equao. Um possvel arquivo de entrada seria o coefs2g.txt, que pode ser
examinado com o Bloco de Notas, e cujas primeiras linhas esto mostradas na Figura 220.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

123

Figura 220: Primeiras linhas do arquivo coefs2g.txt

Nosso programa deve ler o arquivo de entrada e, para cada linha lida, gravar uma linha em um
arquivo de sada contendo os coeficientes lidos e as razes calculadas. Isso deve ser feito
somente para as equaes com razes reais; linhas de entrada que formem equaes com
razes complexas devem ser ignoradas.
// Clculo das razes de diversas equaes
// de 2o grau, com coeficientes lidos de um
// arquivo
// Localizao dos arquivos de e/s
ArqE = uigetfile("*.txt",pwd(),"Arquivo de entrada");
ArqS = uigetfile("*.txt",pwd(),"Arquivo de sada");
// Abertura dos arquivos
daE = mopen(ArqE,"r");
daS = mopen(ArqS,"w");
// Processamento do arquivo de entrada e
// produo do arquivo de sada
while ~meof(daE)
[n,a,b,c] = mfscanf(daE,"%g %g %g");
delta = b^2 - 4*a*c;
if delta >= 0 then
r1 = (-b + sqrt(delta))/(2*a);
r2 = (-b - sqrt(delta))/(2*a);
mfprintf(daS,"\n%8g %8g %8g %8g %8g",...
a,b,c,r1,r2);
end
end
// Fechamento dos arquivos de e/s
mclose(daE);
mclose(daS);
Figura 221: O programa Eq2g5.sce

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

124

A Figura 221 mostra o programa Eq2g5.sce que atende a esta especificao. Neste programa
voc deve reparar que:

A localizao dos arquivos de entrada e sada feita com a verso do comando


uigetfile, que facilita a navegao na rvore de diretrios para o usurio;
Os arquivos de entrada e de sada so abertos no incio do programa e fechados no
fim;
O loop while controlado pela funo ~meof(daE) que testa se o fim do arquivo
de entrada foi encontrado. Seria possvel usar por exemplo o Bloco de Notas para
descobrir o nmero de linhas do arquivo de entrada, e controlar o loop por um
comando for, mas esta no uma boa prtica, pois o programa deveria ser alterado
para cada tamanho de arquivo de entrada.

3.2 Matrizes
Matrizes no Scilab so variveis que contm um nmero potencialmente grande de valores.
na manipulao de matrizes que o Scilab (seguindo o Matlab) mostra uma grande
superioridade sobre linguagens como C ou Fortran.

-->A = [1 2 3; 4 5 6]
A =
1.
4.

2.
5.

3.
6.

Figura 222: Atribuindo uma matriz a uma varivel

A Figura 222 mostra uma maneira simples de se criar uma matriz atravs de um comando de
atribuio na console do Scilab. Os elementos da matriz so dispostos entre colchetes. Espaos
(poderiam ser vrgulas) separam elementos, e ; separam linhas.
3.2.1

Atribuindo valores a uma matriz

possvel extrair o valor de um elemento especfico da matriz, designado por seus ndices
entre parnteses, como mostrado na Figura 223, e tambm podemos atribuir um valor a um
elemento especfico de uma matriz, como mostrado na Figura 224.

-->A = [1 2 3; 4 5 6]
A =
1.
4.

2.
5.

3.
6.

-->e = A(2,3)
e =
6.
Figura 223: Obtendo o valor de um elemento de uma matriz

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

125

A(2,3) , por exemplo, refere-se ao elemento na segunda linha e na terceira coluna; A(1,2)
o elemento na primeira linha e na segunda coluna.

-->A(1,2) = 33

=
1.
4.

33.
5.

3.
6.

Figura 224: Atribuindo um valor a um elemento de uma matriz

O Scilab to orientado para matrizes que todas as variveis Scilab so matrizes. As variveis
simples com que temos trabalhado so, na verdade, matrizes com uma nica linha e uma
nica coluna. possvel perceber isso usando o comando [nl,nc] = size(A) para obter
as dimenses de uma matriz A . Essa funo retorna dois parmetros, o nmero de linhas e o
nmero de colunas da matriz. A Figura 225 mostra dois exemplos de uso da funo size.
-->A = [1 2 3; 4 5 6];
-->[nl,nc] = size(A)
nc =
3.
nl =
2.
-->k = 0;
-->[L,C] = size(k)
C =
1.
L =
1.
Figura 225: Matrizes e a funo size

Uma matriz cresce quando atribumos valores a elementos com ndices superiores aos
ndices j referenciados. Por exemplo, quando fazemos x = 7 estamos criando uma matriz 1
x 1; se em seguida fizermos x(2,3) = 13, a matriz x assume as dimenses 2 x 3, e os
elementos no referenciados recebem o valor zero, como mostrado na Figura 226.

-->x = 7;
-->x(2,3)
x =
7.
0.

// matriz 1x1
= 13
0.
0.

0.
13.

Figura 226: Expanso de uma matriz

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab


3.2.2

126

Vetores linha e coluna

Vetores so matrizes de uma nica linha ou de uma nica coluna. A Figura 227 mostra a
criao na console do Scilab de um vetor linha e de um vetor coluna.
-->v = [10 20 30]
v =
10.
20.
30.
-->u = [10; 20; 30]
u =
10.
Lembrando que o
20.
; separa linhas
30.
Figura 227: Um vetor linha e um vetor coluna

3.2.3

Referenciando partes de uma matriz

O Scilab permite que uma parte de uma matriz seja referenciada tanto para a atribuio de
valores como para a recuperao de valores armazenados.
x

=
23.
23.
21.
88.
65.

30.
93.
21.
31.
36.

29.
56.
48.
33.
59.

50.
43.
26.
63.
40.

91.
4.
48.
26.
41.

28.
12.
77.
21.
11.

68.
15.
69.
84.
40.

50.
- 1.
- 1.
- 1.
40.

91.
- 1.
- 1.
- 1.
41.

28.
12.
77.
21.
11.

68.
15.
69.
84.
40.

-->x(2:4,3:5) = -1
x =

23.
23.
21.
88.
65.

30.
93.
21.
31.
36.

29.
- 1.
- 1.
- 1.
59.

Figura 228: Atribuindo um valor a uma parte de uma matriz

Se x uma matriz 7x5, x(2:4,3:5) denota a parte da matriz compreendida pela interseo
das linhas de 2 a 4 e das colunas de 3 a 5, como mostrado na Figura 228.
x

=
40.
87.
11.
19.
56.

58.
68.
89.
50.
34.

38.
92.
94.
34.
37.

73.
26.
49.
26.
52.

53.
11.
22.
62.
76.

4.
67.
20.
39.
83.

58.
48.
22.
84.
12.

-->x(3:4,4:5) = [-1 -2;-3 -4]


x =
40.
58.
38.
73.
53.
87.
68.
92.
26.
11.
11.
89.
94. - 1.
- 2.
19.
50.
34. - 3.
- 4.
56.
34.
37.
52.
76.

4.
67.
20.
39.
83.

58.
48.
22.
84.
12.

Figura 229: Atribuindo os valores de uma matriz a uma parte de outra matriz

A Figura 229 mostra outro exemplo de utilizao desta notao.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab


x

127

=
21.
75.
0.
33.
66.

62.
84.
68.
87.
6.

56.
66.
72.
19.
54.

23.
23.
21.
88.
65.

30.
93.
21.
31.
36.

29.
56.
48.
33.
59.

50.
43.
26.
63.
40.

66.

23.

93.

56.

43.

-->a = x(2,:)
a =
75.

84.

Figura 230: Obtendo todos os valores de uma linha de uma matriz

Ao se referenciar a uma parte de uma matriz que contm, seja todas as linhas, seja todas as
colunas, possvel usar uma notao simplificada com :. A Figura 230 mostra um exemplo
de uso desta notao para obter todos os elementos em uma linha de uma matriz.
x

=
91.
4.
48.
26.
41.

28.
12.
77.
21.
11.

68.
15.
69.
84.
40.

40.
87.
11.
19.
56.

58.
68.
89.
50.
34.

38.
92.
94.
34.
37.

73.
26.
49.
26.
52.

-->b = x(:,3:5)
b =
68.
40.
58.
15.
87.
68.
69.
11.
89.
84.
19.
50.
40.
56.
34.
Figura 231: Obtendo os elementos de todas as linhas nas colunas de 3 a 5

Outro exemplo est mostrado na Figura 231, onde x(:,3:5) designa a parte de x formada
pelos elementos em todas as linhas e nas colunas de 3 a 5.
3.2.4

Aritmtica matricial

No Scilab as variveis so sempre matrizes e, em conseqncia, as operaes aritmticas


usuais (+, -, *, /, ^) so entendidas pelo Scilab como operaes matriciais. Desta forma, a*b
designa o produto matricial de uma matriz a por uma matriz b. Quando o que se deseja uma
operao elemento a elemento, os mesmos smbolos devem ser utilizados precedidos por um
., como .* ou .^. Vejamos alguns exemplos.
-->x = [1 2 3; 4 5 6];
-->y = [10 20 30; 40 50 60];
-->x + y
ans =
11.
22.
33.
44.
55.
66.
-->x - y
ans =
- 9.
- 18. - 27.
- 36. - 45. - 54.
Figura 232: Adio e subtrao de matrizes

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

128

A Figura 232 mostra exemplos de adio e subtrao de matrizes. Com estas operaes so
sempre feitas elemento a elemento, os operadores .+ e .- no so necessrios, e no
existem no Scilab.
-->x = [1 2 3; 4 5 6]
x =
1.
2.
3.
4.
5.
6.
-->y = [10 20; 30 40; 50 60]
y =
10.
20.
30.
40.
220 = 1x10 + 2x30 + 3x50
50.
60.
-->x * y
ans =
220.
280.
490.
640.
Figura 233: Exemplo de produto matricial

Na Figura 233 ns vemos um exemplo do produto matricial de duas matrizes, obtido com o
operador *, e que segue a frmula da lgebra linear para o produto de uma matriz de
dimenses
por uma matriz de dimenses
, resultando em uma matriz
,
onde
.

-->x = [1 2; 3 4];
-->y = [10 20; 30 40];
-->x * y
Produto
ans =
Matricial
70.
100.
150.
220.
-->x .* y
ans =
Produto Elemento a
10.
40.
Elemento
90.
160.
Figura 234: Produto matricial (*) versus produto elemento a elemento (.*) de duas matrizes

O Scilab emite uma mensagem de erro quando ocorre uma tentativa de multiplicao de
matrizes com dimenses incompatveis com a operao. A Figura 234 mostra a diferena entre
as operaes de produto matricial e produto elemento a elemento.
-->x = [1 2 3; 4 5 6];
-->x * 2
ans =
2.
8.

4.
10.

6.
12.

-->x .* 2
ans =
2.
4.
8.
10.

6.
12.

Figura 235: Multiplicando uma matriz por um escalar

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

129

Uma matriz pode ser multiplicada por um escalar, caso em que os operadores * e .* so
equivalentes, como mostrado na Figura 235.
-->x = [1 2; 3 4];
-->x^2
Produto
ans =
Matricial
x*x
7.
10.
15.
22.
-->x .^ 2
ans =
Exponenciao
1.
4.
Elemento a
9.
16.
Elemento
Figura 236: Exponenciao matricial (^) versus exponenciao elemento a elemento (.^)

Quanto exponenciao, o Scilab interpreta x^3 como x*x*x , ou seja como o produto
matricial triplo da matriz x por ela mesma. o que s faz sentido quando x uma matriz
quadrada. J x .^ 3 interpretado como x .* x .* x, ou seja, o produto triplo da
matriz x por ela mesma, feito elemento a elemento, operao que pode ser feita com
matrizes de dimenses arbitrrias. A Figura 236 mostra um exemplo da diferena entre as duas
operaes.
-->a = [1 2 3; 4 5 6]
a =
1.
2.
3.
4.
5.
6.
-->a'
ans =
1.
2.
3.

4.
5.
6.

Figura 237: Transpondo uma matriz

Se a uma matriz, adesigna a matriz transposta de a, como mostrado na Figura 237.


A

4.
7.
6.
2.
2.
1.
1.
1.
6.
-->IA = inv(A)
IA =
- 0.3333333
1.0909091
0.3333333 - 0.5454545
0.
- 0.0909091

0.1515152
- 0.2424242
0.1818182

Figura 238: A funo inv, que produz a matriz inversa

A funo inv produz a matriz inversa da matriz dada como argumento. A Figura 238 mostra
um exemplo de sua utilizao. Quando multiplicamos uma matriz por sua inversa esperamos
obter a matriz identidade, mas no bem isso o que mostra a Figura 239.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab


-->A * IA
ans =
1.
0.
1.110D-16
1.
5.551D-17
0.
-->IA * A
ans =
1.
8.327D-17
0.
1.
0.
0.

130

- 4.441D-16
- 1.110D-16
1.
0.
0.
1.

Figura 239: O produto de uma matriz por sua inversa ligeiramente diferente da matriz identidade

Ali vemos elementos no nulos fora da diagonal principal tanto de A * IA como de IA *A.
Isso mais uma manifestao dos erros de arredondamento que ocorrem em operaes
aritmticas de ponto flutuante. No caso, esses erros no so motivo de preocupao, pois os
elementos no nulos fora da diagonal tm valor absoluto ordens de grandeza menores que os
elementos das matrizes.
Podemos usar a inversa de uma matriz para resolver um sistema de equaes lineares
onde, por exemplo,

Relembrando, podemos resolver a equao multiplicando os dois lados por

Usando a console do Scilab, o sistema pode ser resolvido com a seqncia de operaes
mostrada na Figura 240.
-->a = [-2 -2 3; 2 1 1;-4 1 3]
a =
- 2. - 1.
3.
2.
1.
1.
- 4.
1.
3.
-->b = [-4 0 1]
b =
- 4.
0.
1.
-->x = inv(a)*b
x =
- 0.5
2.
- 1.
Figura 240: Resolvendo um sistema de equaes lineares

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

131

A preciso do resultado pode ser avaliada calculando


como mostrado na Figura 241.

, o que pode ser feito no Scilab

-->residuo = a*x - b
residuo =
0.
- 2.220D-16
0.
Figura 241: Calculando o erro numrico da soluo encontrada

3.2.5

Construindo matrizes

Vetores com valores regularmente espaados podem ser construdos de forma similar
utilizada no comando for, como mostrado na Figura 242.
-->x = 10:13
x =
10.
11.
12.
-->x = 12:-0.5:10
x =
12.
11.5
11.

13.
10.5

10.

Figura 242: Construo de vetores regulares

Uma outra forma de se conseguir vetores com valores regularmente espaados com o uso da
funo linspace(<valor inicial>, <valor final>, <nmero de
pontos>), onde, alm do valor inicial e do valor final, fornecido o nmero de pontos em
que se deseja dividir o intervalo, ao invs do valor do passo. A Figura 243 mostra dois
exemplos de uso da funo linspace.

Nro. de Pontos
-->x = linspace(0,10,3)
x =
0.
5.
10.

Limites

-->x = linspace(0,10,6)
x =
0.
2.
4.
6.

8.

10.

Figura 243: Usando a funo linspace para construir vetores com valores regularmente espaados

Para se obter matrizes onde todos os elementos tm o valor 0 ou o valor 1, podem ser
utilizadas as funes zeros e ones, como mostrado na Figura 244.
-->x = zeros(2,3)
x =
0.
0.
0.
0.
0.
0.
-->y = ones(2,3)
y =
1.
1.
1.
1.
1.
1.
Figura 244: Matrizes com todos os elementos iguais a 0 ou iguais a 1

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

132

Outra matriz que se pode obter a matriz identidade, atravs da funo eye, como vemos na
Figura 245.
-->I = eye(4,4)
I =
1.
0.
0.
0.
1.
0.
0.
0.
1.
0.
0.
0.

0.
0.
0.
1.

Figura 245: Obtendo uma matriz identidade com a funo eye

Matrizes com elementos randmicos so muito teis para programas que fazem simulaes de
eventos aleatrios, como a chegada de um carro em uma fila. A funo rand gera matrizes
onde cada elemento um nmero entre 0 e 1, sorteado a cada chamada da funo. A Figura
246 mostra dois exemplos de uso desta funo.
Gera nmeros
aleatrios entre
0e1
-->m = rand(2,3)
m =
0.2113249
0.7560439
-->n = rand(2,3)
n =
0.8497452
0.6857310

Novos nmeros
a cada
chamada
0.0002211
0.3303271

0.6653811
0.6283918

0.8782165
0.0683740

0.5608486
0.6623569

Figura 246: Matrizes randmicas

Algumas vezes conveniente gerar matrizes aleatrias com valores inteiros entre, digamos, 0
e 100. Isto se faz com um comando como m = int(rand(2,3)*100), muito til para
quem, como o autor destas linhas, necessita com freqncia de exemplos de matrizes com
valores inteiros. A funo int retorna a parte inteira de seu argumento.
-->x = [1 2; 3 4];
-->y = [10 20; 30 40];
-->z = [x y]
z =
1.
2.
10.
20.
3.
4.
30.
40.
-->z = [x ; y]
z =
1.
2.
3.
4.
10.
20.
30.
40.
Figura 247: Construindo matrizes por justaposio de matrizes j existentes

possvel construir matrizes a partir de matrizes j existentes. Se x e y so matrizes, [x y]


denota uma nova matriz, com y ao lado de x, e [x ; y] denota uma matriz com y abaixo de
x, como mostrado na Figura 247.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

133

-->x = 0:0.8:%pi
x =

0.

0.8

1.6

2.4

-->y = sin(x)
y =
0.

0.7173561

0.9995736

0.6754632

Figura 248: Gerando um vetor como resultado da aplicao de uma funo elementar Scilab a um vetor

A Figura 248 mostra outra forma de se construir uma matriz a partir de uma matriz j
existente, atravs da aplicao de uma funo elementar do Scilab a uma matriz. A matriz
produzida tem as mesmas dimenses da matriz passada como argumento, e cada elemento
resulta da aplicao da funo ao elemento correspondente da matriz original.

3.2.6

Matrizes e Grficos

Matrizes e vetores so imprescindveis para a construo de grficos no Scilab. O comando


mais simples para a gerao de um grfico plot2d(x,y), onde x e y so vetores com o
mesmo nmero de pontos. O Scilab constri um grfico unindo por segmentos de reta os
pontos (x(1), y(1)), (x(2),y(2)) , e assim por diante at o ltimo par de pontos.

-->x = [1 4 7 11]; y = [12 6 15 7];


-->plot2d(x,y)

7,15

15

14

13

1,12

12

11

10

11,7

6
1

10

11

Figura 249: Exemplo de grfico obtido com plot2d

A Figura 249 mostra um exemplo de grfico obtido com o comando plot2d; outro exemplo
est na Figura 250, que mostra que polgonos arbitrrios podem ser traados com plot2d.
Uma infinidade de parmetros pode ser utilizada no comando plot2d, determinando cores e
espessuras de linhas, tracejados, escalas, etc. Neste curso ns veremos apenas comandos
bsicos; voc pode usar o help do Scilab para saber mais e obter um grfico com um
acabamento melhor.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

134

-->x = [2 5 3 4]; y = [ 3 1 4 7];

-->plot2d(x,y)
4,7

3,4
2,3

5,1
Figura 250: Outro exemplo de grfico obtido com plot2d

Para se obter um grfico da funo seno, podemos fazer como mostrado na Figura 251.
Primeiramente gerado o vetor x de abscissas depois, o vetor y obtido pela aplicao da
funo sin ao vetor x, e o comando plot2d(x,y) gera o grfico.

-->x = 0:0.8:3*%pi;
-->y = sin(x);
-->plot2d(x,y)
1.0
0.8

0.6
0.4

0.2

O espaamento
de 0.8 est
grande!

0.0
-0.2

-0.4
-0.6

-0.8
-1.0
0

Figura 251: Grfico da funo seno com espaamento excessivo

A curva obtida no merece bem este nome: est toda quebrada, com cotovelos visveis. o
nmero de pontos utilizado para as abscissas foi pequeno para a nossa acuidade visual. Um
resultado melhor (e que mostra que a gerao de um vetor pela funo linspace mais
confortvel nessas ocasies) est mostrado na Figura 252.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

135

-->x = linspace(0,3*%pi,101)
-->y = sin(x);
-->plot2d(x,y

Com 101 pontos


temos uma curva
mais suave

32

Figura 252: Grfico da funo seno com um espaamento agradvel

A funo plot2d pode ser usada para traar vrias curvas em um nico grfico. O comando
plot2d(x,M) , onde x um vetor coluna, e M uma matriz com o mesmo nmero de linhas
de x faz um grfico de x versus cada coluna de M.
-->x = linspace(0, 3*%pi, 101)';
-->plot2d(x,[sin(x) sin(2*x) sin(3*x)])
1.0
0.8

x um vetor
coluna (e
sin(x),
sin(2*x) e
sin(3*x)
tambm so)

0.6
0.4

0.2

0.0
-0.2

-0.4
-0.6

-0.8
-1.0
0

10

Figura 253: Grfico com vrias curvas obtido com plot2d

A Figura 253 mostra um grfico obtido dessa forma. Repare que o vetor x um vetor coluna, e
que, como na Figura 247, a matriz cujas colunas so mostradas no grfico construda por
justaposio dos vetores coluna sin(x) , sin(2*x) e sin(3*x).
3.2.7

Matrizes de Strings e Arquivos

Matrizes podem ter strings como valores de seus elementos, como mostram os exemplos na
Figura 254.
-->a = ["s1" "s2"]
a =
!s1 s2 !
-->b = ["s1" ; "s2"]
b =
!s1 !
!
!
!s2 !
Figura 254: Exemplos de matrizes de strings

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

136

possvel ler um arquivo e transformar cada uma de suas linhas em um elemento de um vetor
coluna de strings. Para isso deve ser usado o comando mgetl(da), onde da um descritor
de arquivo j aberto.
fpath = uigetfile()
da = mopen(fpath,'r')
linhas = mgetl(da);
mclose(da);
Figura 255: Leitura de um arquivo como um vetor coluna de strings usando o comando mgetl

A Figura 255 mostra um uso tpico do comando mgetl, precedido pela localizao e da
abertura do arquivo, e seguido pelo fechamento do arquivo.
-->linhas
linhas =
!E agora, Jos?
!A festa acabou,
!a luz apagou,
!o povo sumiu,
!a noite esfriou,
!e agora, Jos?
!e agora, voc?
!voc que sem nome,
!que zomba dos outros,
!voc que faz versos,
!que ama, protesta?
!e agora, Jos?

!
!
!
!
!
!
!
!
!
!
!
!

Figura 256: Arquivo fonte visto com o Bloco de Notas e vetor de strings obtido com o comando mgetl

Na Figura 256 ns vemos o efeito desses comandos quando o arquivo escolhido para leitura
o mostrado na parte esquerda da figura, com o famoso poema do Drummond.
3.2.8

Matrizes Numricas e Arquivos

Os comandos j vistos na Seo 3.1.6 podem ser usados para a leitura de matrizes, mas o
Scilab oferece os comandos fscanfMat e fprintfMat que facilitam muito essa tarefa.
Estes comandos lm ou gravam arquivos que contm somente nmeros em formato tabular,
com exceo das primeiras linhas que podem conter textos. Os arquivos so lidos ou gravados
com uma nica execuo desses comandos, que dispensam as operaes de abertura e de
fechamento de arquivos.
O comando fprintfMat(arq, M, "%5.2f", Cabecalho) grava a matriz numrica
M no arquivo arq, que em suas primeiras linhas ir conter os strings que so os elementos do
vetor coluna de strings chamado Cabecalho. Cada elemento de M gravado com o formato
"%5.2f". O vetor de strings Cabecalho normalmente usado para uma explicao sobre
os campos presentes no arquivo.
a = [1 2 3; 4 5 6; 7 8 9];
arq = uigetfile();
Cabecalho = [" Meus Dados "; "Col1 Col2 Col3"]
fprintfMat(arq,a,"%5.2f",Cabecalho);
Figura 257: Gravao de uma matriz em um arquivo com fprintfMat

Na Figura 257 ns vemos um exemplo de uso do comando fprintfMat. O resultado deste


programa um arquivo como o mostrado na Figura 258.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

137

Figura 258: Arquivo gerado pelo programa da Figura 257

Se agora executarmos o programa da Figura 259, escolhendo como entrada o arquivo da


Figura 258, iremos obter uma matriz m idntica matriz a gravada anteriormente.
arquivo = uigetfile();
m = fscanfMat(arquivo)
Figura 259: Leitura de uma matriz com o comand fscanfMat

Vamos agora ver um exemplo de aplicao de matrizes e arquivos. A Figura 260 mostra o
arquivo TempoBHZ.txt exibido com o Bloco de Notas. Cada linha do arquivo contm o nmero
de um ms, a temperatura mdia mxima do ms, a temperatura mnima mdia, a mxima
record, a mnima record, e a precipitao do ms em milmetros de chuva.

Figura 260: O arquivo TempoBHZ.txt

Ns queremos fazer um programa que:

Leia os dados desse arquivo;


Extraia desses dados vetores correspondentes a cada uma das colunas, conforme a
Figura 260;
Gere um grfico que exiba simultaneamente as curvas de mxima mdia, mnima
mdia, mxima record e mnima record.

Examinando o arquivo de entrada ns vemos que ele tem um formato adequado para leitura
com fscanfMat, pois tem uma linha de cabealho, e os dados restantes so todos
numricos e dispostos em um formato tabular.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

138

arqClima = uigetfile();
ClimaBH = fscanfMat(arqClima);
MaxMed = ClimaBH(:,2); // MaxMed = 2a coluna
MinMed = ClimaBH(:,3); // MinMed = 3a coluna
MaxRec = ClimaBH(:,4); // MaxRec = 4a coluna
MinRec = ClimaBH(:,5); // MinRec = 5a coluna
Precip = ClimaBH(:,6); // Precip = 6a coluna
plot2d([1:12],[MaxMed MinMed MaxRec MinRec],...
leg="MaxMed@MinMed@MaxRec@MinRec")
xtitle("Temperaturas Mensais em BH","Ms","Graus C");
Figura 261: O programa ClimaBHZ.sce

A Figura 261 mostra o programa ClimaBHZ.sce que atende a essa especificao. Como voc
pode ver, o programa bastante simples, com a descoberta e leitura do arquivo, seguida das
extraes das colunas, e seguida da gerao do grfico. to simples que aproveitamos para
introduzir duas novas tcnicas que podem melhorar a apresentao de um grfico:
o parmetro extra de plot2d, leg="MaxMed@MinMed@MaxRec@MinRec", que
gera legendas para cada curva em no grfico, e
o comando xtitle, que determina ttulos para o grfico e para cada um dos eixos.
Temperaturas Mensais em BH
40

35

30

Graus C

25

20

15

10

0
0

2
MaxMed
MinMed
MaxRec

6
Ms

8
MinRec

10

12

Figura 262: Grfico gerado pelo programa da Figura 261

Na Figura 262 voc pode ver o efeito destas tcnicas sobre o grfico.
3.2.9

Matrizes e expresses lgicas

O resultado de uma expresso relacional envolvendo matrizes uma matriz de valores


booleanos que resultam da expresso aplicada elemento a elemento, como mostram os
exemplos na Figura 263.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

139

-->a = [3 7;8 2]
a =
3.
7.
8.
2.
-->a > 5
ans =
F T
T F

-->a = [3 7; 8 2];
-->b = [5 6; 7 8];
-->a > b
ans =
F T
T F

Figura 263: Expresses relacionais gerando matrizes booleanas

Uma expresso relacional envolvendo matrizes pode ser empregada em um comando if, mas
isso deve ser feito com muito cuidado, pois a clusula then s ser executada se todos os
elementos da matriz booleana resultante forem iguais a %t. A Figura 264 mostra um exemplo,
onde somente o segundo if tem a sua clusula then executada, pois a matriz resultante da
comparao a > 0 tem todos os elementos iguais a %t.
-->a = [3
-->x = 0;
-->if a >
-->if a >
-->[x y]
ans =
0.

9; 12 1]
y = 0;
5 then; x = 10000; end;
0 then; y = 10000; end;
10000.

Figura 264: Exemplos de emprego de expresses relacionais matriciais em comandos if

Se A for uma matriz e MB uma matriz booleana com as mesmas dimenses de A, A(MB)
designa aqueles elementos de A com correspondentes em MB iguais a %t. Isso nos permite
selecionar elementos de uma forma elegante, como mostra a Figura 265
-->a = [3
-->a(a>5)
a =
3. - 1.

9; 12 1];
= -1
1.
1.

Figura 265: Exemplo de seleo de elementos de uma matriz por uma matriz booleana

3.3 Funes
Funes so uma ferramenta de modularizao da mais alta importncia para a programao
em Scilab. Elas permitem o reaproveitamento de cdigo, a diviso de tarefas em projetos
maiores de programao, e tornam o cdigo mais legvel.
Para ilustrar o uso de funes, vamos desenvolver um programa que l dois inteiros, e , e
que calcula e imprime o nmero de combinaes de tomados a , dado pela frmula

Temos trs fatoriais a calcular, e para isso, vamos procurar reaproveitar o cdigo que
conhecemos para o clculo do fatorial, mostrado na Figura 266.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

140
fat = 1;
for i = 1:n
fat = fat*i;
end

Figura 266: Trecho de cdigo para o clculo do fatorial

A adaptao deste cdigo aos trs fatoriais necessrios para o clculo do nmero de
combinaes nos leva ao programa mostrado na Figura 267, onde cada clculo de fatorial est
destacado, e onde o comando de sada foi omitido.

n=input("n="); k=input("k=");
fat_n = 1; // Clculo do fatorial de n
for i = 2:n
fat_n = fat_n * i;
end
fat_n_k = 1; // Clculo do fatorial de n-k
for i = 2:(n-k)
fat_n_k = fat_n_k * i;
end
fat_k = 1; // Clculo do fatorial de k
for i = 2:k
fat_k = fat_k * i;
end
nComb = fat_n/(fat_n_k * fat_k)
Figura 267: Programa para clculo do nmero de combinaes de n k a k

Voc pode reparar que foram feitas trs adaptaes do cdigo, uma para cada fatorial a ser
calculado. Ns vamos mostrar que com o uso de funes este programa se torna muito mais
claro. Para isso vamos dividir o programa em duas partes: o programa principal e a funo.
n=input("n="); k=input("k=");
nComb = fatorial(n) / (fatorial(n-k) * fatorial(k))
Figura 268: Programa principal para o clculo de combinaes

O programa da Figura 268 faz a mesma coisa, utilizando a funo fatorial cujo cdigo est
na Figura 269.
function fat = fatorial(n)
fat = 1;
for i = 1:n
fat = fat*i;
end
endfunction
Figura 269: A funo fatorial

O programa da Figura 268 contm chamadas da funo fatorial; como usa funes,ele
recebe a designao de programa principal. A execuo de um programa com funes se inicia
pelo programa principal. A execuo de uma chamada transfere o controle para a funo; ao
trmino da execuo da funo, o controle devolvido para o ponto de chamada, em uma
operao que chamamos de retorno da funo.
A cada chamada, um parmetro da funo utilizado, o que permite um reaproveitamento de
cdigo muito mais elegante. A leitura do programa principal tambm muito mais fcil; a
Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

141

inteno do programador mais clara. Para algum que no tivesse construdo o programa da
Figura 267, a percepo da similaridade entre os trechos de clculo do fatorial pode no ser
bvia, e requer esforo de verificao. Para o prprio programador, as substituies utilizadas
para a construo do programa da Figura 267 so uma fonte de enganos.
3.3.1

Sintaxe

function fat = fatorial(n)


fat = 1;
for i = 1:n
fat = fat*i;
end
endfunction
Figura 270: Palavras-chave na definio de uma funo

Funes so definidas com o uso das palavras-chave function e endfunction, que


delimitam o cdigo da funo.

function fat = fatorial(n)


fat = 1;
for i = 1:n
fat = fat*i;
end
Parmetro de
endfunction
Parmetro de Sada
calculado pela
funo

Entrada
fornecido na
chamada da funo

Figura 271: Parmetros formais de entrada e de sada da funo

A funo fatorial que escrevemos possui um parmetro formal de entrada, n, e um


parmetro formal de sada, fat. Parmetros formais so definidos no cdigo da funo, onde
so utilizados como variveis normais. Entretanto, parmetros formais s existem durante a
execuo da funo.
Por contraste, os parmetros usados em chamadas de uma funo so chamados de
parmetros reais, que podem ser variveis ou expresses. No incio da execuo da funo
cada parmetro formal recebe o valor do parmetro real correspondente; a correspondncia
estabelecida pela ordem dos parmetros.
A execuo da funo deve calcular um valor para o parmetro formal de sada; este valor
substitudo na expresso que contm a chamada da funo. Alteraes feitas pela funo
sobre parmetros formais no afetam os parmetros reais.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

142

function [r1, r2] = eq2g(a,b,c)


delta = b^2 - 4*a*c
r1 = (-b + sqrt(delta))/(2*a)
r2 = (-b - sqrt(delta))/(2*a)
endfunction
Uma funo pode ter mais
de um parmetro de sada
Chamada da funo eq2g
[raiz1,raiz2] = eq2g(x,y,z)
Figura 272: Funo com dois parmetros formais de sada

Uma funo pode ter mais de um parmetro formal de sada; a Figura 272 mostra um exemplo
de definio e de chamada de uma funo com dois parmetros formais de sada.
Uma funo cria um espao novo para variveis, que podem ter nomes iguais aos de variveis
j definidas no programa principal. Variveis definidas por uma funo so chamadas variveis
locais. Na funo da Figura 269 a varivel i uma varivel local; o programador desta funo
no precisa se preocupar com qualquer outra varivel de mesmo nome definida no programa
principal. Essa delimitao de escopo de variveis uma propriedade essencial para permitir o
desenvolvimento de funes por programadores independentes; se no existisse, todos os
programadores participantes de um projeto de maior vulto teriam que se preocupar com a
escolha de nomes de variveis no utilizados por seus colegas.
3.3.2

Funes, arquivos fonte e o Scilab

Uma funo normalmente escrita em um arquivo com o mesmo nome da funo, e com a
extenso .sci, distinta dos arquivos com programas principais Scilab, que tm a extenso .sce.

Figura 273: Um arquivo com uma funo aberto no Scipad

A Figura 273 mostra o arquivo com a funo da Figura 272 aberto no Scipad, onde voc pode
reparar que o arquivo e a funo tm o mesmo nome, sendo que o arquivo tem a extenso
.sci.
A mera existncia de um arquivo com uma funo no basta para que o Scilab saiba de sua
existncia. necessrio incorporar a funo ao Scilab, o que pode ser feito com o comando
getf(<nome do arquivo com a funo>)
que deve ser colocado no programa principal. Um exemplo de uso do comando getf est
mostrado na Figura 274.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

143

getf("fatorial.sci")
n=input("n="); k=input("k=");
nComb = fatorial(n) / (fatorial(n-k) * fatorial(k))
Figura 274: Programa principal para o clculo de combinaes com o comando getf

Ateno: o arquivo com a funo deve estar no mesmo diretrio em que se encontra o
programa principal, e este deve ser o diretrio corrente do Scilab (veja a Seo 3.1).
Parmetros de entrada e de sada de uma funo podem ser qualquer coisa: nmeros, strings,
booleanos, arrays de qualquer tipo, e at mesmo outra funo! A Figura 275 mostra um
exemplo de uma funo que recebe uma funo f como parmetro e que faz o seu grfico
para um vetor x.
function PlotaPontos(f,x)
y = f(x);
plot2d(x,y,style=-1);
endfunction
Figura 275: Uma funo que faz o grfico de outra funo recebida como parmetro

O clculo de combinaes uma operao que pode ser aproveitada em outras ocasies.
Como vimos, o cdigo de uma funo mais facilmente reaproveitado do que o cdigo de um
programa. Uma boa idia ento transformar o programa da Figura 274 em uma funo, o
que resulta no cdigo mostrado na Figura 276.
function nComb = Combinacoes(n,k)
nComb = fatorial(n) / (fatorial(n-k) * fatorial(k))
endfunction
Figura 276: Uma funo para o clculo do nmero de combinaes de n k a k

Um programa principal equivalente ao da Figura 268 est mostrado na Figura 277. Voc deve
reparar no encadeamento de chamadas: o programa principal chama a funo
Combinacoes, que por sua vez chama por trs vezes a funo fatorial.
getf("Combinacoes.sci")
getf("fatorial.sci")
n=input("n="); k=input("k=");
printf("nComb(%d,%d) = %d",n,k,Combinacoes(n,k))
Figura 277: Um programa principal que usa a funo Combinacoes

A Figura 278 ilustra o encadeamento das chamadas neste programa.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

144

Programa
Principal

Funo
nComb
Funo
Fatorial
Figura 278: Encadeamento de chamadas

3.3.3

Funes, Matrizes, Loops e Induo

Nesta seo ns apresentamos um roteiro que explora matrizes, loops e idias da induo
matemtica para desenvolver duas funes que podero ser aproveitadas em algoritmos mais
complexos. Crie um diretrio de trabalho, abra o Scilab e use o menu File/Change Directory
para mudar para este diretrio de trabalho. Depois abra o Scipad, clicando sobre o menu
Applications/Editor no Scilab.
3.3.3.1 Soma dos Elementos de um Vetor
Como um primeiro exemplo, vamos programar uma funo para calcular a soma de todos os
elementos de um vetor A. O primeiro passo para desenvolver uma funo a determinao de
suas entradas e de suas sadas. Qual a idia? Vamos fornecer funo um vetor, e esta
funo deve retornar um nico valor com a soma de todos os elementos. Em outras palavras,
esta funo tem um nico parmetro de entrada, o vetor, e um nico parmetro de sada, a
soma. Com isto podemos comear a escrever nossa funo usando o Scipad, como mostra a
Figura 279
function s = Soma(A)
// Calcula a soma dos elementos do vetor A
endfunction
Figura 279: Cabealho da funo Soma

Salve este arquivo no seu diretrio de trabalho com o nome Soma.sci. Com isto j
escrevemos o cabealho da funo, ou seja:

demos um nome significativo funo,


determinamos e demos nomes para seus parmetros formais de entrada e de sada.

Como vimos, parmetros formais so utilizados no cdigo da funo; parmetros reais so os


parmetros utilizados no momento da chamada da funo. Tanto para entender melhor a
relao entre parmetros formais e reais como para testar a nossa funo, vamos construir um
programa que ir utilizar a funo Soma, gerando e calculando a soma dos elementos de
vetores aleatrios. Para isto, no Scipad use o menu File/New, digite um programa como o da ,
Figura 280, e salve-o com o nome TestaSoma.sce.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

145

// Programa que testa a funo Soma


a = int(10*rand(1,4))
sa = Soma(a);
printf("\n Soma = %g",sa);
b = int(10*rand(1,6))
sb = Soma(b);
printf("\n Soma = %g", sb);
c = int(10*rand(1,9))
sc = Soma(c);
printf("\n Soma = %g",sc);
Figura 280: O programa TestaSoma.sce

O programa ir gerar 3 pequenos vetores de inteiros entre 0 e 10 e, para cada um deles, ir


imprimir seus valores e tambm o valor calculado pela funo Soma. Repare que o ; foi
omitido nos comandos de criao dos vetores aleatrios para que o Scilab imprima
automaticamente os seus valores. Repare tambm que a funo Soma chamada com trs
parmetros reais distintos de entrada: na primeira chamada, a, um vetor com 4 elementos, na
segunda, b, com 6 elementos, ena terceira, c, com 9 elementos, e com trs parmetros reais
distintos de sada: sa, sb e sc. A cada chamada da funo seus parmetros formais (s e A)
so mapeados nos parmetros reais correspondentes.
O funcionamento da funo Soma poder ser verificado por inspeo visual dos resultados,
talvez com o auxlio de uma planilha ou de uma calculadora.
Temos agora que avanar no desenvolvimento da funo Soma. Para isto, uma boa idia
utilizar, no Scipad, o menu Windows/Split(side by side), o que nos leva a uma janela como a da
Figura 281, onde podemos ver simultaneamente os cdigos da funo e do programa testador.

Figura 281: Tela do Scipad dividida em duas janelas pelo menu Windows/Split(side by side)

Como faremos para calcular a soma de todos os elementos do vetor A? Vamos avanar aos
poucos. Suponhamos que uma varivel s contenha o valor dos primeiros k elementos de A,
ou seja, suponhamos que de alguma forma ns conseguimos colocar em s o valor de A(1)
+ A(2) + ... + A(k). No difcil ver que, se fizermos s = s + A(k+1), s
passar a conter o valor dos primeiros k+1 elementos de A. Se depois disso fizermos s = s
+ A(k+2), s passar a conter o valor dos primeiros k+2 elementos de A. Se repetirmos
este passo at atingir o ltimo elemento de A, teremos em s a soma de todos os elementos
de A, como desejvamos. A Figura 282 ilustra um passo deste algoritmo.
Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

146

Sabemos portanto como avanar no clculo da soma, mas como comear? No caso, simples.
Quando k=0, a parte do vetor com os k primeiros elementos vazia, e portanto, sabemos que
s = 0 para k = 0.
Para k = 0,
s =0
1

10

44 13 44 46 29 30 34 34 42 13
Para k = 3,
s = 101

Para k = 4,
s = 101 + 46 = 147

Figura 282: Um passo do algoritmo de soma

Falta ainda saber como terminar, dado que, a cada chamada, a funo poder receber
argumentos reais de tamanhos diferentes. O problema que, ao programar a funo, no se
sabe qual o tamanho do parmetro formal A. Para isto a funo length de grande valia.
Se M uma matriz, length(M) retorna o produto do nmero de linhas pelo nmero de
colunas de M. Se M um vetor, ou bem o nmero de linhas ou bem o nmero de colunas de M
igual a 1, e portanto, length(M) nos fornece o nmero de elementos de M.
Com isto chegamos verso final da funo Soma, mostrada na Figura 283.
function s = Soma(A);
// Calcula a soma dos elementos do vetor A
s = 0;
for k = 1:length(A)
s = s + A(k);
end
endfunction
Figura 283: Verso final da funo Soma

J podemos portanto testar o nosso programa. Fazendo File/Exec no Scilab, e selecionando o


arquivo TestaSoma.sce, temos entretanto uma surpresa desagradvel: uma mensagem de
erro, como mostra a Figura 284.
sa = Soma(a);
!--error 4
undefined variable : Soma
at line
3 of exec file called by :
dores\Scilab\TestaSoma.sce');disp('exec done')
Figura 284: Erro ao tentar executar o programa TestaSoma

O que aconteceu que o Scilab, ao executar o programa TestaSoma, no estava ciente da


existncia da funo Soma. Nos esquecemos de usar a funo getf(arquivo com
funo) no programa principal. Corrigindo isso, chegamos ao formato final do programa
testador, mostrado na Figura 285.
// Programa que testa a funo Soma
getf("Soma.sci");
a = int(10*rand(1,4))
sa = Soma(a);
printf("\n Soma = %g\n",sa);
Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

147

b = int(10*rand(1,6))
sb = Soma(b);
printf("\n Soma = %g\n", sb);
c = int(10*rand(1,9))
sc = Soma(c);
printf("\n Soma = %g\n",sc);
Figura 285: O programa TestaSoma.sce, agora com getf

importante notar que os arquivos TestaSoma.sce e Soma.sci devem estar em um mesmo


diretrio, e este deve ser o diretrio corrente do Scilab. A tela abaixo mostra uma possvel
sada deste programa.
-->exec('C:\Documents and
Settings\usuario\Desktop\Scilab\TestaSoma.sce');disp('exec
done');
a =
3.
3.
2.
5.
Soma = 13
b =
4.
3.
5.
5.
4.
2.
Soma = 23
c =
6.
4.
9.
0.
4.
2.
4.
2.
1.
Soma = 32
exec done
Figura 286: Uma possvel sada do programa TestaSoma.sce

3.3.3.2 Menor Valor Presente em um Vetor


Neste exemplo ns iremos desenvolver uma funo que encontra o menor valor presente em
um vetor. O primeiro passo tambm a escrita do cabealho da funo, que pode ser visto na
Figura 287.
function m = Minimo(A)
// Encontra o menor valor presente no vetor A
endfunction
Figura 287: Cabealho da funo Minimo

Nossa funo tem portanto:

um nome significativo, Minimo;

um parmetro formal de entrada, A, que deve ser um vetor do qual se quer saber o
valor do menor elemento,

e um parmetro formal de sada, m, que deve receber na execuo da funo este


valor do menor elemento de A.

Feche o Scipad se ele j tiver arquivos abertos e o abra novamente para construir esta funo.
Salve a funo em um arquivo Minimo.sci em seu diretrio de trabalho.
Precisamos tambm desenvolver um programa testador para a funo, e podemos faz-lo a
partir do programa TestaSoma.sce. Para isto, use o Scipad para abrir o programa
TestaSoma.sce e use o menu File/Save as para salv-lo com o nome TestaMinimo.sce. Use
tambm o menu Windows/Split (side by side) para conseguir trabalhar simultaneamente com
os dois arquivos do seu programa.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

148

Muito bem, temos o cabealho da funo Minimo, temos um programa testador, e agora
vamos desenvolver a funo propriamente dita. Vamos procurar seguir um raciocnio similar
ao utilizado para o clculo da soma dos elementos de um vetor. Suponhamos que uma varivel
m contenha em um dado momento o menor valor entre os primeiros k elementos do vetor.
Para avanar simples:

comparamos o valor de m com o valor de A(k+1) ;

se m for menor ou igual a A(k+1) , seu valor j tambm o menor entre os


primeiros k+1 elementos do vetor (podem haver empates, mas isto no um
problema) e pode permanecer inalterado;

se m for maior que A(k+1) , devemos fazer m = A(k+1) para que seu valor passe
a ser o menor entre os primeiros k+1 elementos do vetor.

Figura 288: Dois passos do algoritmo que encontra o menor valor presente em um vetor

A Figura 288 ilustra dois passos deste algoritmo. No difcil acreditar que ns encontraremos
o menor valor presente no vetor aplicando repetidamente os passos acima at encontrarmos
o limite superior do vetor.
Precisamos entretanto de um ponto de partida para o algoritmo. Isto pode ser facilmente
obtido, pois claro que, para k == 1 , A(1) o menor elemento entre os k (=1) primeiros
elementos de A, no ? Podemos agora chegar verso final da funo Minimo, mostrada na
Figura 289.
function m = Minimo(A)
// Encontra o menor valor presente no vetor A
m = A(1);
for k = 2:length(A)
if m > A(k)
m = A(k);
end
end
endfunction
Figura 289: A funo Mnimo

Execute agora o programa TestaMinimo.sce; voc dever obter uma sada parecida com a
Figura 290.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab


=
5.
4.
Mnimo = 2
b =
1.
2.
Mnimo = 1
c =
6.
9.
Mnimo = 0
exec done

149

2.

8.

8.

8.

5.

9.

0.

7.

4.

6.

8.

0.

8.

Figura 290: Sada do programa TestaMinimo.sce

3.3.4

Recursividade

Ns vimos que uma funo pode chamar outra funo, que pode chamar outra funo, que
pode chamar outra funo, em um encadeamento de chamadas de profundidade arbitrria.
Uma funo pode tambm chamar a si prpria, o que a torna uma funo recursiva. Ns
veremos ao longo desse curso que uma formulao recursiva muitas vezes a forma mais
natural para a descrio de um algoritmo.
Como um primeiro exemplo, vamos mostrar uma funo recursiva para o clculo do fatorial de
um nmero. Ns sabemos que
e que, para

A funo fatorialR na Figura 291 calcula o fatorial de um nmero usando de forma muito
natural essas equaes.
function fat = fatorialR(n)
if n > 1 then
fat = n*fatorialR(n-1)
else
fat = 1
end
endfunction
Figura 291: Funo recursiva para o clculo do fatorial

Para compreender melhor o funcionamento da execuo de uma funo recursiva, considere o


programa FatorialR_Teste da Figura 292.
// Teste de FatorialR
getf("FatorialR.sci");
n = input("n = ");
while n > 0 do
printf("\n%d! = %d",n,FatorialR(n));
n = input("n = ");
end
Figura 292: Programa TestaFatorialR.sce

Considere tambm a verso de fatorialR da Figura 293, onde tambm colocamos


comandos printf envolvendo a chamada (recursiva) da funo.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

150

function fat = FatorialR(n)


// Comente os printf para no imprimir
printf("\nIniciando FatorialR(%d)",n);
if n > 1 then
fat = n * FatorialR(n-1);
else
fat = 1;
end
printf("\nRetornando Fatorial(%d) = %d",n,fat)
endfunction
Figura 293: A funo fatorialR, instrumentada para acompanhamento de sua execuo

A execuo deste programa pode gerar a sada mostrada na Figura 294, onde acrescentamos
chaves para indicar a correspondncia entre chamadas e retornos da funo.

n = 5

Iniciando FatorialR(5)
Iniciando FatorialR(4)
Iniciando FatorialR(3)
Iniciando FatorialR(2)
Iniciando FatorialR(1)
Retornando Fatorial(1)
Retornando Fatorial(2)
Retornando Fatorial(3)
Retornando Fatorial(4)
Retornando Fatorial(5)
5! = 120

=
=
=
=
=

1
2
6
24
120

Figura 294: Sada do programa TestaFatorialR.sce

Chamadas e retornos de funes seguem um mecanismo clssico em computao, chamado


de pilha. Em uma pilha de livros normalmente coloca-se um novo livro encima da pilha, e
retira-se o livro no topo da pilha.
Fat(1)

Fat(4)
Prog

Fat(2)

Fat(2)

Fat(2)

Fat(3)

Fat(3)

Fat(3)

Fat(3)

Fat(3)

Fat(4)

Fat(4)

Fat(4)

Fat(4)

Fat(4)

Fat(4)

Fat(5)

Fat(5)

Fat(5)

Prog

Prog

Prog

Fat(5)

Fat(5)

Fat(5)

Fat(5)

Fat(5)

Fat(5)

Prog

Prog

Prog

Prog

Prog

Prog

Prog

Figura 295: Pilha de execuo de FatorialR

A Figura 295 ilustra a evoluo da pilha de execuo do programa TestaFatorialR.sce quando


executado com n == 5. No incio somente o programa principal est em execuo. A
primeira chamada de FatorialR feita com o parmetro real 5. Temos neste momento o
programa principal e uma instncia da funo em execuo. Mas o clculo do fatorial de 5
exige outra chamada de FatorialR, desta vez com o parmetro real 4, o que nos leva a ter em
execuo o programa principal e duas instncias de FatorialR. Para o clculo do fatorial de
4, precisamos do fatorial de 3, e assim vamos at chegarmos a uma pilha com o programa
principal e cinco instncias de FatorialR, que na ltima vez ter sido chamada com o
parmetro real 1.
Com o parmetro real igual a 1 FatorialR retorna sem outra chamada recursiva, o que
reduz a quatro o nmero de instncias em execuo. Isso marca o incio de uma sequncia de
Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

151

retornos e de desempilhamentos, at termos novamente somente o programa principal em


execuo.
A recursividade portanto uma outra forma de se prescrever um comportamento repetitivo
para um programa. possvel por exemplo formular o algoritmo de descoberta do menor valor
presente em um vetor como uma funo recursiva. Uma possibilidade usa a seguinte relao
de recorrncia:

se length(A) == 1, o menor valor presente em A A(1)


se length(A) > 1, o menor valor presente em A o menor entre A(1) e o menor
valor presente em A(2:length(A))

o que nos leva a uma formulao recursiva do mesmo algoritmo que usamos na funo
Minimo. Outra relao de recorrncia que pode ser usada :

se length(A) == 1, o menor valor presente em A A(1)


se length(A) > 1, o menor valor presente em A o menor dentre (o menor valor
presente na metade esquerda de A) e (o menor valor presente na metade direita de A)

A partir desta segunda relao de recorrncia ns podemos derivar a funo recursiva da


Figura 296.
function m = MinimoR(x)
if length(x) == 1 then
m = x(1)
else
half = int(length(x)/2);
minLeft = MinimoR(x(1:half));
minRight = MinimoR(x(half+1:length(x)));
if minLeft <= minRight then
m = minLeft
else
m = minRight
end
end
endfunction
Figura 296: Funo MinimoR, recursiva

3.3.5

Funes e Desenvolvimento Top-down

Uma tcnica comum de programao a utilizao da chamada de uma funo antes do


desenvolvimento da prpria funo, em uma tcnica conhecida como desenvolvimento topdown. Em um certo momento do desenvolvimento, o programador capaz de especificar o
que ele quer que a funo faa, deixando para depois o trabalho de determinar como faz-lo.
Vamos aqui ilustrar o emprego de desenvolvimento top-down para construir um programa
que:

Leia uma srie de nmeros inteiros maiores ou iguais a 2


Para cada nmero lido, encontre o menor nmero primo que seja maior ou igual a ele.
Por exemplo, se o nmero lido for 4, o programa deve encontrar o nmero primo 5; se
for 11, o programa deve encontrar 11, que j primo. Da matemtica ns sabemos
que o conjunto de nmeros primos infinito, ou seja, que sempre existe um nmero
primo maior ou igual a um nmero dado.
O programa deve terminar quando o usurio entrar com um nmero menor que 2.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

152

Construir um programa que, seguindo a estrutura mostrada na Figura 207, leia uma srie de
dados, faa alguma coisa com eles, e termine conforme o desejo do usurio, uma idia que j
foi explorada por diversas vezes neste curso. Encontrar o menor primo maior ou igual a um
nmero lido nos parece complicado, mas vamos dar incio ao desenvolvimento do programa
deixando isso para depois. Veja uma proposta na Figura 297.
n = input("n = (use n < 2 se quiser parar):");
while n >= 2
// Encontra o menor primo >= n
// e imprime o resultado
printf("O menor primo >= %d %d",...
n,MenorPrimoMaiorOuIgualA(n))
// L n
n = input("n = (use n < 2 se quiser parar):");
end
Figura 297: Programa principal para Menor Primo >= n

Podemos ver que o programa principal cuida da interao com o usurio, empurrando o
problema de se encontrar o menor primo para uma funo MenorPrimoMaiorOuIgualA,
que ainda no existe. No existe, mas j demos a ela um nome significativo, e especificamos
que:

A funo tem um nico parmetro de entrada, que o nmero digitado pelo usurio
A funo deve retornar o nmero primo que desejamos.

Ou seja, j definimos o cabealho da funo MenorPrimoMaiorOuIgualA. Muito bem,


vamos agora encarar o seu desenvolvimento. O algoritmo simples: vamos testar
sequencialmente os inteiros a partir do nmero lido, parando ao encontrar um nmero primo.
Sim, mas como vamos saber se um inteiro primo? No vamos nos preocupar com isso agora.
Outra vez, vamos especificar uma funo e adiar o problema. Veja a Figura 298.
function p = MenorPrimoMaiorOuIgualA(n)
p = n;
while ~Primo(p)
p = p+1
end
endfunction
Figura 298: A funo MenorPrimoMaiorOuIgualA

Como funciona a funo Primo, no sabemos ainda, mas especificamos que:

a funo tem um parmetro formal de entrada, n, que o nmero que queremos


testar se ou no primo;
o resultado do teste o parmetro formal de sada, que deve ser %t se o nmero for
primo, e %f seno.

Para saber se um nmero primo vamos decomp-lo como um produto de fatores inteiros
satisfazendo
. Um nmero inteiro maior ou igual a 2 primo se seus nicos fatores
so 1 e o prprio . A funo Primo pode ento ser escrita como mostrado na Figura 299,
function ehPrimo = Primo(n)
ehPrimo = (n == MenorFator(n));
endfunction
Figura 299: A funo Primo

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

153

Precisamos agora desenvolver a funo MenorFator. O algoritmo que vamos utilizar


bastante direto: vamos usar um inteiro p, com valor inicial 2, e que iremos a cada passo de um
loop incrementar e testar se ele um divisor. Para este teste vamos usar a funo Scilab
modulo(n,p) , que calcula o resto da diviso de n por p. O loop para ao encontrar o
primeiro divisor, o que sempre acontece pois n divisvel por n. Ao trmino do loop, p contm
o menor divisor de n.
function p = MenorFator(n)
p = 2;
while modulo(n,p) <> 0
p = p + 1;
end
endfunction
Figura 300: A funo MenorFator

Com isso ns terminamos o desenvolvimento do nosso programa. importante que voc


observe os ganhos obtidos com esse enfoque:

Ao desenvolver o programa principal, ns nos preocupamos com a interao com o


usurio e, exceto pela definio de funcionalidade, pudemos esquecer do problema de
encontrar o nmero primo que desejamos;
Ao desenvolver a funo MenorPrimoMaiorOuIgualA, ns esquecemos da
interao com o usurio e nos preocupamos somente com a pesquisa seqencial por
um primo a partir de um nmero dado; saber se um nmero primo tambm um
problema deixado para outro momento;
Ao desenvolver a funo Primo, nosso foco simplesmente descobrir um algoritmo
para saber se um nmero inteiro primo ou no; todo o contexto restante pode ser
esquecido. Para isso o parmetro de entrada n comparado com o seu menor fator, e
a descoberta deste menor fator deixada para depois;
Ao desenvolver a funo MenorFator, a nica preocupao encontrar o menor
divisor de um nmero inteiro.

esta diviso de tarefas que permite o domnio de programas mais complexos. O


desenvolvimento de cada funo pode ser feito por um desenvolvedor em momentos
diferentes, ou por pessoas distintas em uma mesma equipe.
3.3.6

Desenhando Mapas

Para se desenhar um polgono usando o Scilab basta colocar as coordenadas de seus vrtices
em vetores x e y de mesmo tamanho, e executar plot2d(x,y). Por exemplo, a sequncia
de comandos executados na console do Scilab
--> x = [1 2 3 4 2 1];
--> y = [1 2 1 2 4 1];
--> plot2d(x,y,rect=[0 0 6 6]);
(onde o parmetro rect indica as coordenadas de um retngulo que determina os limites de
exibio) produz o grfico mostrado na Figura 301.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

154

0
0

Figura 301: Um polgono

Se quisermos acrescentar outro polgono, podemos fazer


--> w = [4 5 5 4];
--> z = [0.5 0.5 1.5 0.5];
--> plot2d(w,z);
obtendo o grfico mostrado na Figura 302.
6

0
0

Figura 302: Dois polgonos

Repare que foram utilizados dois pares de vetores, um para cada polgono desenhado. Quando
temos muitos polgonos a desenhar, como o caso do mapa que faremos em seguida, torna-se
interessante representar todos os polgonos em um nico par de vetores com as coordenadas
de todos os vrtices. preciso entretanto encontrar um meio de informar ao Scilab quais so
os pontos que separam dois polgonos. Isto porque se fizermos
--> X = [x w];
--> Y = [y z];
--> plot2d(X,Y,rect=[0 0 6 6]);
vamos obter o desenho da Figura 303, onde o ponto final do primeiro polgono e o ponto
inicial do segundo polgono foram (naturalmente) emendados pelo Scilab.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

155

0
0

Figura 303: Efeito no desejado ao traar dois polgonos

Este problema resolvido inserindo-se pares de pontos com coordenadas iguais a %inf
(representao de infinito em ponto flutuante; veja a Seo 2.1) para indicar ao Scilab os
pontos de separao entre dois polgonos. Experimente agora fazer, na console do Scilab,
--> X = [x %inf w];
--> Y = [y %inf z];
--> clf
--> plot2d(X,Y,rect=[0 0 6 6]);
e voc obter a figura desejada, com polgonos separados. O comando clf limpa a janela
grfica do Scilab.
Um mapa simples pode ser representado por uma tabela de pares latitude-longitude. Em
princpio estas tabelas podem ser utilizadas diretamente para o desenho dos mapas utilizando
a funo plot2d mas, como j vimos, necessrio algum mecanismo para separar os
polgonos isolados representando cada ilha, lago ou continente.
No nosso site, faa o download do arquivo world.txt (que obtivemos na referncia
(Wolffdata), e de onde retiramos grande parte desta seo), e abra-o utilizando o Bloco de
Notas (Notepad). Um pequeno exame desse arquivo basta para verificar que a separao entre
os polgonos est ali representada pelas coordenadas com valores 9999.
Faa agora um programa que
1) Leia este arquivo em uma matriz Mapas. Use para isto as funes uigetfile e
fscanfMat.
2) Extraia desta matriz dois vetores, Lat e Long, correspondendo s duas colunas da
matriz lida.
3) Utilize uma funo colocaInfinito para substituir nos vetores Lat e Long os
valores 9999 por %inf. Para isto construa na sua funo um loop que faa uma
varredura completa do vetor que receber como parmetro de entrada, e fazendo a
substituio quando for o caso. Use a funo length(x) (que devolve o nmero de
elementos em um vetor linha ou coluna) para determinar o limite superior de seu
loop.
4) Use plot2d para obter o desenho do mapa representado no arquivo.
5) Utilize uma funo suaviza para construir os vetores LatS e LongS a partir dos
vetores Lat e Long, utilizando a regra
Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Ambiente e Linguagem Scilab

156

LatS(i) = (Lat(i-1)+Lat(i)+Lat(i+1))/3
se Lat(i-1), Lat(i) e Lat(i+1) forem diferentes de infinito, e LatS(i) =
Lat(i) no caso contrrio. Esta regra deve ser usada para os valores de i entre 2 e
length(Lat)-1; para os extremos do vetor, temos LatS(1) = Lat(1), e
LatS(length(Lat)) = Lat(length(Lat)). A construo de LongS
similar.
6) Utilize a funo scf(3) para abrir outra janela grfica, e faa
plot2d(LatS,LongS) para descobrir o efeito da suavizao.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Algoritmos

157

4 Algoritmos
4.1 Definio e Caractersticas
Um problema de transformao de informao descreve uma entrada de informao e
propriedades requeridas de uma informao de sada. Um algoritmo resolve um problema de
transformao, sendo constitudo por uma prescrio de passos que transformam uma
informao de entrada em outra informao de sada. Cada passo prescrito deve ser uma
operao garantidamente realizvel, seja por operaes elementares, seja por outro
algoritmo. Um programa a concretizao de um algoritmo em uma linguagem executvel.
Trs questes so bsicas para a caracterizao de problemas e algoritmos:

Especificao: qual exatamente o problema de transformao de informao que


queremos resolver?
Correo: um dado algoritmo resolve mesmo o problema proposto em sua
especificao?
Eficincia: com qual consumo de recursos computacionais (essencialmente, tempo e
memria) o algoritmo executa a sua funo?

Ns iremos a seguir detalhar um pouco mais cada uma dessas questes.


4.1.1

Especificao

Especificaes surgem de um processo de anlise de uma necessidade de transformao de


informao. Uma especificao no esttica; muitas vezes uma especificao modificada
durante e mesmo aps o processo de desenvolvimento de um programa. Uma condio no
prevista muitas vezes a causa de uma alterao em uma especificao. Como um exemplo,
no programa que vimos para a soluo de muitas equaes de 2 grau com coeficientes em
um arquivo (Figura 221), ns no demos um tratamento especial para o caso de termos o
primeiro coeficiente nulo, o que provoca uma diviso por zero no clculo das raizes. Se em
uma linha do arquivo de coeficientes tivermos
, a diviso por zero provocar uma
interrupo da execuo do programa, sem o processamento das equaes restantes. Se isso
no for um comportamento aceitvel, necessrio modificar a especificao para dar um
tratamento adequado a esta situao, que poderia ser, por exemplo, ignorar a linha com
, ou seno resolver a equao de primeiro grau resultante.
Em problemas reais comum que a fase de especificao seja a etapa mais demorada e a mais
cara de um projeto de desenvolvimento. No existe situao pior para uma equipe de
desenvolvimento do que, ao dar por terminado um sistema, constatar que ele no atende s
necessidades do cliente, necessidades que, por deficincias no processo de anlise, no foram
explicitadas na especificao.
Apesar dessa importncia, neste curso ns procuraremos lidar com problemas cuja
especificao bem simples, pois nosso objetivo aqui a criao de uma cultura algortimica
para o aluno. Tcnicas de anlise e de especificao de sistemas so matrias que voc poder
depois estudar em cursos de engenharia de software.
4.1.2

Correo

possvel verificar se um algoritmo atende a uma especificao por um exame de sua


estrutura, com a construo de uma prova formal de sua correo. Na prtica somente
algoritmos muito pequenos tm uma prova formal de correo vivel. O que se faz produzir
uma argumentao informal da correo de um algoritmo; alm desta argumentao, testes
Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Algoritmos

158

so usados para se ganhar convico do bom funcionamento de um algoritmo concretizado


em um programa. entretanto importante ter em mente que testes podem descobrir erros,
mas raramente podem garantir a sua ausncia. Este problema vem do fato de que mesmo
algoritmos muito simples tm tantas entradas possveis que testes s podem cobrir uma
nfima frao dessas possibilidades.

SC

SC

SC

SC

Figura 304: Um somador de 4 bits

Usando um exemplo retirado de (Dijkstra, 1972) vamos considerar uma transformao bsica
de informao, feita por um somador em cascata, similar ao mostrado na Figura 304, mas com
largura de 32 bits. Se algum quiser considerar o somador como uma caixa preta a ser testada,
teramos
(considerando as duas entradas de 32 bits cada) valores para as entradas a serem
testadas, o que claramente inexeqvel. Uma argumentao baseada na estrutura do
somador o que nos propicia a convico de sua correo. Se estamos convencidos da
correo de um circuito de soma completa, como o mostrado na Figura 68 (e estamos, pela
forma de desenvolvimento a partir da tabela da verdade), e se compreendemos a lgica do
arranjo em cascata, no temos dificuldades para acreditar no bom funcionamento do somador
de 32 bits.
A compreenso completa da estrutura de um programa grande estamos falando de milhares
ou mesmo milhes de linhas de cdigo, produzidas por vrios desenvolvedores por sua vez
dificilmente atingvel. No possvel testar completamente um programa, e nem possvel
compreender completamente sua estrutura. E agora, Jos? Bom, isso mesmo. No existe
uma boa sada. A indstria de software investe em qualidade de desenvolvimento, em testes,
mas quase sempre vende programas sem garantia.
Neste curso ns iremos trabalhar com programas pequenos, todos com menos de 50 linhas. A
convico de correo ser tratada tanto com argumentos estruturais como por testes.
4.1.3

Eficincia e Complexidade Computacional

Para uma mesma especificao possvel encontrar algoritmos que apresentam enormes
diferenas em sua eficincia. O temo complexidade computacional, ou simplesmente
complexidade, usado para designar como o uso de recursos computacionais por um
algoritmo varia em funo de seus dados de entrada. Complexidade temporal refere-se
eficincia em tempo de execuo; complexidade espacial refere-se eficincia no uso de
memrias.
Na Cincia da Computao, um algoritmo tem complexidade maior que outro quando menos
eficiente, e no, como se poderia pensar com o uso habitual da palavra, mais complicado do
que o outro. Na verdade, espera-se que algoritmos mais complicados tenham complexidade
computacional menor do que a de algoritmos mais simples. Algoritmos com complexidade
maior (menos eficientes) e mais complicados no tm nenhuma vantagem de uso, e
inevitavelmente caem no esquecimento.
Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Algoritmos

159

Para ganharmos algum sentimento de como algoritmos que satisfazem uma mesma
especificao podem diferir em eficincia, ns vamos fazer alguns experimentos de medidas
de tempo gasto com a fatorao de nmeros inteiros, um problema de importncia
fundamental para a rea de segurana da informao. A segurana da criptografia da maior
parte dos sistemas atuais depende da dificuldade da fatorao de nmeros semi-primos, isto
, nmeros que so formados pelo produto de dois primos. Estamos aqui falando de nmeros
grandes: chaves criptogrficas atuais tm costumeiramente 1024 ou 2048 bits, que
correspondem a nmeros com 308 ou 616 algarismos decimais.
O Scilab oferece a funo timer() que permite medir o tempo gasto na execuo de trechos
de um programa. A primeira execuo da funo timer() zera e dispara um cronmetro;
cada chamada subseqente da funo timer() retorna o valor em segundos do tempo
decorrido desde a chamada anterior da funo.
// Programa para fatorar nmeros inteiros
getf("MenorFator.sci")
n = input("n = ");
while n >= 2
timer(); p = MenorFator(n) ; tempoGasto = timer();
// Imprime o resultado
printf("\nTempo = %8.6fs, %6d divisvel por %6d",
tempoGasto,n,p);
if n == p then
printf(" **PRIMO**")
end
n = input("n = ");
end
Figura 305: O programa Fatora.sce

Na Figura 305 ns vemos o programa Fatora.sce, que l nmeros e encontra o menor


fator divisor dos nmeros lidos, destacando em sua sada os nmeros primos. A verificao
feita pela funo MenorFator, mostrada na Figura 300. Repare como a funo timer()
utilizada no programa Fatora.sce para medir o tempo gasto na execuo da funo
MenorFator.
Nosso primeiro experimento muito simples. Vamos utilizar o programa Fatora.sce para
encontrar o menor divisor de 131101, que primo, e tambm de 131103, que no .
n = 131101
Tempo = 3.062500s, 131101 divisvel por 131101 **PRIMO**
n = 131103
Tempo = 0.000000s, 131103 divisvel por

Figura 306: Tempos para fatorar nmeros primos e no primos

Na Figura 306 ns vemos o resultado do experimento. Encontrar o menor fator de um nmero


primo tomou mais de 3 segundos, enquanto o tempo tomado para encontrar o menor fator de
um nmero divisvel por 3 foi to pequeno a funo timer retornou zero. Isso nos leva a
importante observao de que o tempo gasto pode variar muito com a instncia de um
problema. fcil entender o que aconteceu olhando o cdigo da funo MenorFator.
Nmeros primos so o pior caso para a funo MenorFator. Na primeira chamada, foram
feitas 131103 execues da funo modulo, e, na segunda, apenas 3. Com isso, uma primeira

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Algoritmos

160

observao: algoritmos podem ter seu tempo de execuo dependente da instncia especfica
do problema que resolve.
Muitas vezes ns estamos interessados na anlise do pior caso de um algoritmo. Ns iremos
em seguida relatar outros experimentos feitos com o programa Fatora.sce. Nestes
experimentos ns vamos precisar de nmeros primos, e para isso o arquivo 200000primos.txt,
que contm os 200.000 primeiros nmeros primos, de grande utilidade. Diversos sites na
Internet, como (Andrews), contm arquivos com nmeros primos ou programas que geram
nmeros primos. A Figura 307 mostra as primeiras e ltimas linhas deste arquivo.

Figura 307: Primeiros e ltimos nmeros primos no arquivo 200000primos.txt

No segundo experimento, fizemos o programa Fatora.sce fatorar por diversas vezes se o


nmero 131101, que primo. Veja os resultados na Figura 308.
n = 131101
Tempo = 2.984375s, 131101 divisvel por 131101 **PRIMO**
n = 131101
Tempo = 3.078125s, 131101 divisvel por 131101 **PRIMO**
n = 131101
Tempo = 3.015625s, 131101 divisvel por 131101 **PRIMO**
Figura 308: Variaes no tempo de execuo de um programa com os mesmos dados de entrada

Voc pode ver que um mesmo programa apresenta variaes no tempo gasto para a fatorao
do mesmo nmero primo. Isso se deve a uma srie de fatores, o principal deles sendo o fato
de que, em um sistema operacional como o Windows ou o Linux, um programa no executa
sozinho, mas compartilha o processador e outros recursos do computador com outros
programas e com o prprio sistema operacional. Esse compartilhamento coordenado pelo
sistema operacional, e o programador Scilab no tem qualquer controle sobre a forma como
se d este compartilhamento. por isso que uma mesma funo, chamada com os mesmos
parmetros, pode apresentar diferenas de desempenho a cada execuo.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Algoritmos

161

Tabela 20: Tempos (segundos) gastos com a funo MenorFator em um notebook e em um desktop

Primo
Notebook
257
0,01560
521
0,04680
1031
0,03120
2053
0,10920
4099
0,17160
8209
0,39000
16411
0,68640
32771
14,19609
65537
29,17219
131101
58,03237
262147
11,94968
524309
23,50935
1048583
47,04990
2097169
93,05460

Desktop
0,03125
0,01563
0,04688
0,01563
0,06250
0,21875
0,29688
0,76563
1,53125
2,93750
6,29688
11,21875
24,54688
49,60938

Outro experimento procura capturar o impacto do valor do nmero primo recebido como
parmetro sobre o tempo de execuo da funo MenorFator. A Tabela 20 mostra os
resultados obtidos com diversos nmeros primos, obtidos com dois computadores com
velocidades distintas. O grfico da Figura 309 resulta desta tabela, e ele torna clara a relao
de linearidade entre o valor do nmero primo e o tempo consumido pela funo
MenorFator.

Figura 309: Tempo para fatorao em funo do valor de nmeros primos em dois computadores

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Algoritmos

162

A Cincia da Computao se preocupa exatamente em determinar a complexidade de um


algoritmo por uma anlise do algoritmo em si; experimentos somente ajudam a formar uma
intuio. Um exame da funo MenorFator (Figura 300) nos teria permitido prever seu
comportamento. Quando o nmero testado primo, a funo modulo aplicada a todos os
inteiros menores ou iguais a ele. Como a se encontra todo o esforo computacional,
poderamos j ter previsto um crescimento linear do tempo de execuo em funo do valor
do nmero primo examinado.
A constante de linearidade em si depende do computador onde a funo MenorFator
executada. Para o notebook, o tempo gasto com um nmero primo aproximadamente
igual a
segundos; para o desktop,
segundos, ou seja, o
desktop aproximadamente duas vezes mais rpido do que o notebook (no tome isso como
uma afirmativa genrica; estamos falando do desktop e do notebook empregados nos
experimentos).
Para poder comparar algoritmos, procura-se determinar a complexidade temporal de um
algoritmo de forma independente da velocidade de um computador especfico e de outros
fatores que afetam o tempo de execuo de um programa. Um algoritmo tem a sua
complexidade conhecida quando conseguimos encontrar uma funo que descreva a ordem de
crescimento de seu tempo de execuo com relao ao tamanho de sua entrada.
E qual o tamanho da entrada da funo MenorFator? Seu nico parmetro de entrada
um nmero, que, para fins de anlise do algoritmo, podemos supor ser representado como
binrio sem sinal com bits. Ns vimos que o tempo para o pior caso da execuo de
MenorFator cresce linearmente com o valor do primo fatorado, que prximo de , onde
o nmero de bits necessrios para a representao do primo.

Figura 310: Tempos para fatorao em funo do nmero de bits de um nmero primo em dois computadores

Se o tamanho da entrada de um problema, ns dizemos que uma funo


caracteriza
a complexidade de um algoritmo quando seu tempo de execuo limitado por
multiplicado por uma constante. Ns dizemos que sua complexidade da ordem de
,o
que escrito
(pronuncia-se de
). No caso do algoritmo utilizado pela
funo MenorFator, temos
, e por isso dizemos que o algoritmo tem
Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Algoritmos

163

complexidade exponencial. A idia aqui ter informao til sobre o desempenho de um


algoritmo, que no dependa da velocidade de computadores especficos. A constante de
multiplicao serve para isso: ela absorve pequenas perturbaes na execuo, e pode
incorporar diferenas de desempenho dos computadores.
Vamos agora considerar a funo MenorFator2, mostrada na Figura 311, que implementa
um algoritmo melhor para a fatorao de um nmero. Este novo algoritmo se baseia na
observao de que, se um divisor de um inteiro positivo , porque existe tal que
. Se
,
e um quadrado perfeito; seno, ou bem
ou bem
. Isto significa que s precisamos testar a divisibilidade para os inteiros menores ou
iguais raiz quadrada de ; se neste intervalo no encontrarmos nenhum divisor, j
poderemos concluir que primo.
function p = MenorFator2(n)
limite = int(sqrt(n));
p = 2;
while modulo(n,p) <> 0 & p <= limite
p = p + 1;
end
if modulo(n,p) <> 0 then
p = n;
end
endfunction
Figura 311: A funo MenorFator2

Uma anlise direta da funo MenorFator2 mostra que so realizadas chamadas da funo
mdulo em nmero igual raiz quadrada do valor do nmero primo sendo fatorado. Portanto,
sua complexidade
. Experimentamos a funo MenorFator2
para verificar fatorar 2750159, o maior primo presente no arquivo 2000000primos.txt, e o
tempo gasto no desktop foi de 0,047 segundos, enquanto que a funo MenorFator gastou
88,360 segundos, uma diferena enorme de desempenho. Quando
, a funo modulo
chamada aproximadamente 1024 vezes pela MenorFator, e somente 32 vezes pela
MenorFator2. Quando
, a funo modulo chamada aproximadamente
vezes pela MenorFator, e 1024 vezes pela MenorFator2. Ao passar o nmero
de bits da entrada de 10 para 20, a MenorFator demora 1024 vezes mais, enquanto a
MenorFator2 demora 32 vezes mais.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Algoritmos

164

Funo de
complexidade

Tamanho da Instncia do Problema


10

20

30

40

50

60

0,00001 0,00002 0,00003 0,00004 0,00005 0,00006


segundos segundos segundos segundos segundos segundos

n2

0,0001
0,0004
0,0009
0,0016
0,0025
0,0036
segundos segundos segundos segundos segundos segundos

n3

0,001
0,008
0,027
0,064
0,125
0,216
segundos segundos segundos segundos segundos segundos

n5

0,1
3,2
24,3
1,7
5,2
13,0
segundos segundos segundos minutos minutos minutos

2n

0,001
1,0
17,9
segundos segundos segundos

3n

0,059
58
segundos minutos

6,5
anos

12,7
dias
3855
sculos

35,7
anos

366
sculos

2 108 1,3 1013


sculos sculos

Figura 312: Quadro comparativo de funes de complexidade

A Figura 312, extrada do livro (Garey & Johnson, 1979), nos ajuda a formar uma idia do que
esperar do desempenho de algoritmos com funes de complexidade exponencial quando
aplicados a problemas grandes.

Maior instncia que um computador resolve em 1 hora


Computador Computador
Funo de
Computador
100x mais
1000x mais
complexidade
Atual
rpido
rpido
N
100 N
1000 N
n

n2

10 M

31,6 M

n3

4,64 Z

10 Z

n5

2,5 W

3,98 W

2n

X + 6,64

X + 9,97

3n

Y + 4,19

Y + 6,29

Figura 313: Efeito do aumento da velocidade de computadores sobre o tamanho dos problemas resolvveis

Computadores de um mesmo preo dobram de velocidade em menos de dois anos, mas


algoritmos com funes de complexidade exponencial so relativamente pouco afetados. O
efeito de termos computadores 100 ou 1000 vezes mais rpidos que os atuais sobre
algoritmos com funes de complexidade exponencial est mostrado na Figura 313, que
tambm foi retirada de (Garey & Johnson, 1979). Ali vemos que se hoje um computador
resolve em uma hora um problema de tamanho, digamos, 200, usando um algoritmo
,
com um computador 1000 vezes mais rpido conseguiremos resolver um problema de
tamanho ~210.

4.2 Pesquisa
Vamos agora estudar um problema clssico da Cincia da Computao, que a pesquisa para
verificar se um elemento procurado existe em uma tabela. Extenses deste problema fazem
parte do nosso dia a dia, em mquinas de busca como Google e Yahoo, ou na localizao de
uma palavra em um arquivo. Vamos examinar aqui dois algoritmos: a pesquisa seqencial e a
Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Algoritmos

165

pesquisa binria. Como um exemplo ns vamos utilizar algoritmos de pesquisa para testar a
primalidade de um nmero, a tabela sendo composta pelos nmeros primos presentes no
arquivo 200000primos.txt. Obviamente isto s funciona para nmeros menores ou iguais ao
maior nmero presente no arquivo, 2750159.
A especificao do problema que iremos resolver de duas maneiras distintas :
Faa um programa que:

4.2.1

Leia o arquivo 200000primos.txt, que contm os primeiros 200000 nmeros primos;


Leia repetidamente nmeros inteiros e, para cada nmero lido, verifique se o nmero
primo pesquisando por ele na tabela;
O programa deve parar quando o nmero lido for 0 (zero).

Pesquisa Seqencial

A Figura 314 mostra o programa VerificaPrimos3.sci, onde podemos notar que:

Os primeiros comandos fazem a leitura da tabela de nmeros primos;


O programa apresenta a nossa velha conhecida estrutura de repetio controlada pelo
usurio;
A verificao efetiva da primalidade foi deixada para a funo Primo3, que tem como
parmetros de entrada o nmero digitado pelo usurio e a tabela lida do arquivo.

// Programa para deteo de nmeros primos


getf("Primo3.sci")
getf("seqSearch.sci")
arqTab = uigetfile("*.txt",pwd(),"Arquivo com Tabela");
tabPrimos = fscanfMat(arqTab);
n = input("n = ");
while n >= 2
timer(); eh_Primo = Primo3(n,tabPrimos); tempoGasto = timer();
// Imprime o resultado
printf("\nTempo gasto = %g segundos", tempoGasto);
if eh_Primo then
printf("\nO nmero %d primo!\n\n",n);
else
printf("\nO nmero %d no primo!\n\n", n)
end
n = input("n = ");
end
Figura 314:O programa VerificaPrimos3.sci, que utiliza pesquisa seqencial

A funo Primo3 apenas um envelope sobre uma funo de pesquisa seqencial, como
mostra a Figura 315.
function ePrimo = Primo3(n,tabela)
ePrimo = seqSearch(n,tabela) ~= -1;
endfunction
Figura 315: A funo Primo3

A funo seqSearch mostrada na Figura 316 implanta uma pesquisa seqencial. Ali
podemos observar que:
Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Algoritmos

166

O vetor table examinado sequencialmente a partir de sua primeira posio.


O loop de pesquisa pra por um de dois motivos: quando o limite superior da tabela
for atingido, ou quando a chave for encontrada.
Aps a sada do loop feito um teste para se saber por qual motivo o loop while
terminou.
Se a chave procurada no consta da tabela, o parmetro de sada p recebe o valor -1,
uma conveno til para quem chama a funo, como a funo Primo3.
function p = seqSearch(key,table)
i = 1;
while i <= length(table) & table(i) ~= key
i = i+1;
end
if i <= length(table) then
p = i;
else
p = -1;
end
endfunction
Figura 316: A funo seqSearch para pesquisa seqencial

Quanto complexidade da pesquisa seqencial, no difcil ver que se o tamanho da


tabela, o nmero de comparaes com a chave feito em uma pesquisa por um elemento
presente na tabela varia entre 1 e ; pesquisas por elementos que no constam da tabela (o
que constitui o pior caso) consomem sempre comparaes com a chave. Se considerarmos
todas as chaves presentes na tabela como tendo a mesma probabilidade de serem
pesquisadas, o algoritmo far em mdia
comparaes por pesquisa por chave constante
da tabela.
O nmero de comparaes cresce portanto linearmente com o tamanho da tabela, e ns
dizemos que o algoritmo de pesquisa seqencial
, ou seja, da ordem de , ou ainda,
dizemos que a pesquisa seqencial tem complexidade linear.
4.2.2

Pesquisa Binria

Quando a tabela tem suas entradas dispostas em ordem crescente ou decrescente ns


podemos usar um algoritmo muito mais eficiente para a pesquisa, e que se assemelha ao
mtodo como ns humanos procuramos palavras em um dicionrio. A primeira comparao
feita no com o primeiro elemento da tabela, mas com o elemento no meio da tabela.
Supondo que os elementos da tabela esto em ordem crescente, se a chave procurada for
menor que o elemento no meio da tabela, podemos restringir a pesquisa metade inferior da
tabela, pois a parte superior s contm elementos maiores do que a chave procurada. Da
mesma forma, se a chave procurada for maior que o elemento no meio da tabela, podemos
restringir a pesquisa metade superior da tabela.
O mtodo reaplicado parte restante da tabela, e continua at que ou a chave encontrada,
ou a parte da tabela em considerao tem tamanho igual a 0, situao em que podemos
concluir que a chave no consta da tabela. A denominao de pesquisa binria vem do fato da
diviso do tamanho do problema por 2 a cada passo do algoritmo.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Algoritmos

167
function p = BinarySearch(key,table,low,high)
if high < low then
p = -1;
else
m = int((low+high)/2);
if key == table(m) then
p = m;
else
if key < table(m) then
p = BinarySearch(key,table,low,m-1);
else
p = BinarySearch(key,table,m+1,high);
end
end
end
endfunction
Figura 317: A funo recursiva BinarySearch

A Figura 317 mostra uma implementao direta da pesquisa binria como uma funo
recursiva.
function position = binSearch(key,table)
low = 1; high = length(table);
while high - low > 1
m = int((high+low)/2);
if key >= table(m) then
low = m;
end
if key <= table(m) then
high = m;
end
end
if key == table(high) then
position = high;
else
if key == table(low) then
position = low;
else
position = -1;
end
end
endfunction
Figura 318: A funo binSearch

A funo binSearch (Figura 318) uma implementao no recursiva em Scilab do


algoritmo de pesquisa binria, onde podemos observar que:

a funo utiliza dois ponteiros, low e high, que indicam a cada passo qual parte da
tabela que pode conter a chave procurada. A condio low <= high mantida em
todas as alteraes de valores dessas variveis.
a cada passagem do loop o elemento comparado com a chave buscada est na posio
m = int(high+low)/2 .
o ponteiro low tratado de forma a manter sempre a afirmativa se key <
table(low), ento key no consta da tabela, que valida inicialmente, e que
permanece vlida a cada atualizao de low;

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Algoritmos

168

o ponteiro high cumpre papel similar, mantendo sempre vlida a afirmativa se key
> table(high), ento key no consta da tabela ;
quando o loop termina, a parte da tabela que pode conter um elemento igual chave
est entre low e high e, pela condio de trmino do loop e pela relao entre low
e high,0 <= high low < = 1.
os testes que sucedem ao loop permitem decidir se a tabela contm ou no um
elemento igual chave procurada.

A anlise da complexidade do pior caso da pesquisa binria simples. A cada passo o tamanho
da parte da tabela que pode conter a chave dividido por 2, e o algoritmo termina quando o
tamanho desta parte igual a 1. Se a tabela tem elementos, teremos no pior caso,
comparaes, onde
indica a funo teto, que mapeia um nmero real no menor inteiro
maior ou igual a . No caso da tabela armazenada no arquivo 200000primos.txt, temos no pior
caso
comparaes para completar a pesquisa. Compare
isso com o pior caso da pesquisa seqencial, que pode necessitar de 200.000 passos para
terminar. Pior: se a tabela dobrar de tamanho, passando a ter 400.00 elementos, o algoritmo
de pesquisa binria ir passar a necessitar de 19 comparaes, uma a mais, enquanto que o
algoritmo de pesquisa seqencial poderia necessitar de 400.000 passos.
Por estes argumentos algum poderia pensar que, em casos em que temos uma tabela
ordenada, a opo pela pesquisa binria em detrimento da pesquisa seqencial uma escolha
bvia, mas nem sempre este o caso. A pesquisa seqencial mais simples, mais fcil de
programar, e menos propensa a erros de programao. E muitas vezes trabalhamos com
tabelas pequenas, onde a diferena de desempenho entre os dois algoritmos no
importante. Ao programar, nunca se esquea do kiss principle, um acrnimo para uma frase
em ingls que todos os bons programadores dizem a si prprios todos os dias: keep it simple,
stupid. Ou seja, s complique quando inevitvel.

4.3 Ordenao
Outro problema clssico da Cincia da Computao a ordenao, que consiste em, dado um
vetor A, obter outro vetor com os mesmos elementos de A, dispostos em ordem crescente ou
decrescente, como mostra a Figura 319.

34 56 27 45 12 44 34
1

12 27 34 34 44 45 56

Vetor no
ordenado
Vetor
ordenado

Figura 319: Ordenao de um vetor

4.3.1

Seleo e Troca

O primeiro algoritmo que iremos estudar conhecido como o mtodo de Seleo e Troca (em
ingls, Select Sort), por motivos que se tornaro bvios. Vamos comear apresentando o
cabealho de uma funo, apresentado na Figura 320.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Algoritmos

169
function sA = SelectSort(A)
// Constri o vetor sA com os
// mesmos elementos do vetor A
// dispostos em ordem crescente.
endfunction
Figura 320: Cabealho de uma funo de ordenao

Isso j nos permite desenvolver um programa para testar a funo, mostrado na Figura 321.
getf("SelectSort.sci");
a = int(10*rand(1,4))
aa = SelectSort(a)
b = int(10*rand(1,6))
bb = SelectSort(b)
c = int(10*rand(1,9))
cc = SelectSort(c)
Figura 321: O programa SelectSort_teste.sce

O programa SelectSort_teste.sce bastante simples, e nos permite verificar por


inspeo visual a correo da funo por testes com pequenos vetores randmicos. Ele gera 3
pequenos vetores randmicos que so passados como parmetros de entrada para a funo.
Repare na ausncia dos ; em quase todos os comandos, de forma a tirar proveito do eco
automtico do Scilab para a impresso dos vetores antes e depois da ordenao.
O algoritmo de ordenao por seleo e troca tambm desenvolvido por um raciocnio
indutivo:

Suponhamos que as k-1 primeiras posies do vetor A j contenham elementos em


suas posies finais;
Selecionamos o elemento de menor valor entre A(k) e A(length(A)) ;
Trocamos o valor deste menor elemento com o valor em A(k). Com isso teremos
mais um elemento em sua posio final, e podemos fazer k = k+1.

O algoritmo se inicia com k igual a 1, o que torna vazia a poro do vetor com elementos em
suas posies finais.
Na Figura 322 ns vemos uma ilustrao deste mtodo:

No primeiro passo o menor elemento entre 1 (igual a k) e 7 (comprimento do vetor)


tem o valor 12, e se encontra na posio 7. Os valores nas posies 1 e 7 so trocados,
e k passa a valer 2.
No segundo passo, o menor elemento entre 2 (igual a k) e 7 tem o valor 27, e se
encontra na posio 3. Ele trocado com o elemento na posio 2, e k passa a valer 3.

Desta forma o algoritmo progride, e termina quando a penltima posio do vetor recebe o
seu valor final o que significa que a ltima posio tambm estar corretamente preenchida.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Algoritmos

170
1

34 56 27 45 12 44 34
1

12 56 27 45 34 44 34
1

12 27 56 45 34 44 34
1

12 27 34 45 56 44 34
1

12 27 34 34 56 44 45
1

12 27 34 34 44 56 45
1

12 27 34 34 44 45 56
Figura 322: Ordenao por Seleo e Troca

J temos condies de dar um primeiro refinamento funo SelectSort, que mostramos


na Figura 323.
function sA = SelectSort(A)
for k = 1:length(A)-1
// Seleciona a posio entre A(k) e
// A(length(A)) que contm o menor valor
// Troca o valor de A(k) com o valor na
// posio selecionada.
end
sA = A;
endfunction
Figura 323: Primeiro refinamento da funo OrdenaPorSeleo

Prosseguindo no refinamento, vamos atacar inicialmente o problema da troca de valores entre


duas posies do vetor A. Trocar os valores de duas variveis x e y no uma operao bvia.
Se fizermos x = y; y = x, o valor antigo de x que queramos armazenar em y perdido.
Se fizermos y = x; x = y, teremos o problema inverso. A soluo o uso de uma varivel
temporria (adjetivo empregado para variveis cuja utilidade tem um carter destacadamente
local e auxiliar) temp, e fazer temp = x; x = y; y = temp, o que nos d a soluo
desejada. Muito simples, depois que sabemos.
Para a etapa de seleo do menor elemento, ns j desenvolvemos uma funo parecida, a
Minimo (Figura 289, pgina 148), que retorna (tem como parmetro de sada) o menor valor
presente em um vetor. Podemos aproveitar o seu cdigo, adaptando-o aos requisitos que
temos agora. Precisamos de uma outra funo, que vamos chamar de MinimoPos, que:

procure o menor valor no em todo o vetor de entrada, mas em parte dele, e


informe alm do menor valor, a posio onde foi encontrado.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Algoritmos

171
function [m,im] = MinimoPos(A,low,high)
// Encontra o menor valor
// presente no vetor A entre as
// posies low e high, e informa
// sua posio no vetor
m = A(low);
im = low;
for k = low+1:high
if m > A(k)
m = A(k);
im = k;
end
end
endfunction
Figura 324: A funo SelecionaMenor

Como voc pode reparar na Figura 324, as modificaes introduzidas memorizam na varivel
im a posio onde o mnimo corrente foi encontrado (nas situaes em que m atualizada),
restringem o espao da busca apenas aos elementos de A com ndices entre os parmetros de
entrada low e high, e acrescentam um parmetro de sada.
Se a funo Minimo mereceu a construo de um programa para seu teste, uma boa idia
fazer o mesmo para a funo MinimoPos, que um pouco mais complicada. Voc poderia
pensar que, indiretamente, o programa OrdenaPorSelecao_teste j o faria, mas
construir um testador independente tem a vantagem de simplificar o contexto de uso da
funo MinimoPos.
// Programa que testa a funo MinimoPos
getf("MinimoPos.sci");
getf("PrintMatrix.sci");
a = int(10*rand(1,10));
PrintMatrix("A",a);
inicio = input("Inicio = ");
fim = input("Fim = ");
while inicio > 0
[m im] = MinimoPos(a,inicio,fim)
inicio = input("Inicio = ");
fim = input("Fim = ");
end
function PrintMatrix(Label, M);
printf("\n%s = [",Label);
for i = 1:length(M)
printf("%3d",M(i));
end
printf("]")
endfunction
Figura 325: O programa MinimoPos_teste e a funo PrintMatrix

A Figura 325 mostra o programa MinimoPos_teste.sce, juntamente com uma funo


auxiliar PrintMatrix, cuja utilidade simplesmente a impresso de um vetor em um
formato mais agradvel. Este programa gera um vetor com 10 elementos aleatrios, e permite
que o usurio repetidamente escolha um ponto inicial para a seleo da posio com o menor
elemento a partir do ponto inicial. A Figura 326 mostra uma sada deste programa.
Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Algoritmos

172

A = [ 2 7
Inicio = 2
Fim = 5
im =
3.
m =
0.
Inicio = 4
Fim = 6
im =
4.
m =
3.

0]

Figura 326: Uma sada do programa MinimoPos_teste

Com a confiana adquirida sobre a funo MinimoPos ns podemos chegar ao refinamento


final da funo SelectSort, mostrado na Figura 327.
function sA = SelectSort(A)
for k = 1:length(A)-1
// Seleciona a posio entre A(k) e
// A(length(A)) que contm o menor valor
[Min iMin] = MinimoPos(A,k,length(A));
// Troca os valores de A(k) com o valor
// na posio selecionada.
temp = A(k);
A(k) = A(iMin);
A(iMin) = temp;
end
sA = A;
endfunction
Figura 327: A funo SelectSort

Vamos agora examinar a complexidade deste algoritmo. Para ordenar um vetor de tamanho ,
o primeiro passo do algoritmo de seleo e troca realiza
comparaes; o segundo,
; o terceiro,
, e assim por diante, at chegar ao ltimo passo, quando feita uma nica
comparao. Podemos concluir que o nmero de comparaes realizado dado por

Para suficientemente grande, o nmero de comparaes se aproximar de


. Ou seja, o
nmero de comparaes necessrias para a execuo do algoritmo cresce com o quadrado do
tamanho do vetor, e portanto o algoritmo de ordenao por seleo e troca
.
A Figura 328 mostra um grfico com medidas de desempenho obtidas para o mtodo de
seleo e troca em dois computadores. Voc pode reparar que para ordenar um vetor com
5000 elementos o tempo gasto pelo computador mais rpido j significativo, da ordem de 1
minuto.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Algoritmos

173

Figura 328: Tempos medidos para ordenao por seleo e troca de vetores aleatrios em um notebook (*) e em
um desktop (+)

4.3.2

Intercalao (MergeSort)

a
1

b
3

15 15 19 22
1

10 16 19 20 23 27

Intercalao de a e b
3 4 5 6 7 8

10

10 15 15 16 19 19 20 22 23 27
Figura 329: Uma operao de intercalao

Intercalao (em ingls, merge) o nome dado ao processo de produo de um vetor


ordenado a partir de dois outros j ordenados, como mostrado na Figura 329. O algoritmo de
ordenao por intercalao consiste em dividir o vetor de entrada em duas partes, ordenar
cada uma delas separadamente, e depois obter o vetor ordenado realizando uma operao de
intercalao. A ordenao por intercalao aplicada recursivamente a cada parte, a no ser
que a parte a ser ordenada seja de tamanho 1, quando a recurso termina pois a parte j est
trivialmente ordenada.
A Figura 330 mostra um exemplo de ordenao por intercalao de um vetor com 16 posies.
Na parte superior da figura as pequenas setas indicam divises de uma parte do vetor; na
parte inferior (em vermelho) as pequenas setas indicam operaes de intercalao de partes j
ordenadas.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Algoritmos

174

12 72 26 54 98 73 0 59 30 25 62 11 61 67 33 2

16

12 72 26 54 98 73 0 59

12 72 26 54

12 72

12

98 73 0 59

26 54

72

26

12 72

54

98 73
98

26 54

73
73 98

12 26 54 72

0 59
0

59
0 59

0 59 73 98
0 12 26 54 59 72 73 98

30 25 62 11 61 67 33 2
30 25 62 11
30 25
30

61 67 33 2
62 11

25

25 30

62

61 67
11

11 62

61

33 2
67

33

61 67

11 25 30 62

2 33

2 33 61 67

2 11 25 30 33 61 62 67

0 2 11 12 25 26 30 33 54 59 61 62 67 72 73 98

16

Figura 330: Exemplo de ordenao por intercalao com n = 16 = 2

Os pequenos nmeros no lado esquerdo da figura indicam o tamanho de cada parte. Como 16
uma potncia de dois, a estrutura de divises e intercalaes muito regular. A Figura 331
mostra um exemplo com um vetor de tamanho 10, quando nem sempre as duas partes
resultantes de uma diviso (ou a serem intercaladas) tm o mesmo tamanho.
60 85 6 82 92 56 57 81 5 55

10

60 85 6 82 92

60 85 6

10

56 57 81

60 85

60

85

82 92
6

56 57 81 5 55

82

60 85

92
82 92

6 60 85

56 57
56

5 55
57

81

56 57

55

5 55

56 57 81

6 60 82 85 92
5

5 55 56 57 81

6 55 56 57 60 81 82 85 92

Figura 331: Exemplo de ordenao por intercalao com n = 10

O cdigo da funo MergeSort est mostrado na Figura 332. Voc deve reparar que o
cdigo transcreve o algoritmo de forma bastante direta, e que pressupe a existncia de uma
funo Merge que realiza as intercalaes.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Algoritmos

175
function sA = MergeSort(A)
if length(A) <= 1 then
sA = A;
else
m = int((1+length(A))/2);
sA = Merge(MergeSort(A(1:m)),...
MergeSort(A(m+1:length(A))));
end
endfunction
Figura 332: A funo MergeSort

A codificao da funo Merge (Figura 333) tambm bastante intuitiva. Voc deve reparar
que:

pA, pB e pM so ponteiros que indicam as posies em foco nos vetores fonte e no


vetor resultado;
O primeiro loop realiza a intercalao propriamente dita, a cada passo colocando em
M(pM) o menor entre A(pA) e B(pB), e avanando adequadamente pA ou pB; este
loop termina quando pA ou pB atinge o limite do seu vetor;
O segundo loop s efetivamente executado quando a sada da fase de intercalao
se deu pelo esgotamento dos elementos de B e consiste em copiar os elementos
restantes de A em M;
Da mesma forma, o terceiro loop s efetivamente executado quando a sada da fase
de intercalao se deu pelo esgotamento dos elementos de A, e consiste em copiar os
elementos restantes de B em M.
function M = Merge(A,B)
pA = 1; pB = 1; pM = 1
while pA <= length(A) & pB <= length(B)
if A(pA) <= B(pB) then
M(pM) = A(pA);
pA = pA+1;
else
M(pM) = B(pB);
pB = pB+1;
end
pM = pM+1;
end
// Esgota A
while pA <= length(A)
M(pM) = A(pA);
pM = pM+1;
pA = pA+1;
end
// Esgota B
while pB <= length(B)
M(pM) = B(pB);
pM = pM+1;
pB = pB+1;
end
endfunction
Figura 333: A funo Merge

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

12 72 26 54 98 73 0 59 30 25 62 11 61 67 33 2

16

Algoritmos

176
12 72 26 54 98 73 0 59

30 25 62 11 61 67 33 2

12

72
12 72

26

54
26 54

12 26 54 72

98

73
73 98

59
0 59

0 59 73 98

30

25

25 30

62

11

11 62

11 25 30 62

61

67

33

61 67

2 33

16 passos
16 passos

2 33 61 67

16 passos
8

0 12 26 54 59 72 73 98

2 11 25 30 33 61 62 67

4 = log2(16)

fcil ver que o nmero de operaes elementares de uma operao de intercalao de dois
4
12 72 26 54de tamanhos
98 73 0 59 e30 2562 da
11 ordem61 de
67 33 2
vetores
ordenados
. Isso porque cada passo do
algoritmo produz um elemento do vetor de sada, cujo tamanho
. A complexidade da
2
12por
72 intercalao
26 54
98 73 pode
0 59 ser 30inferida
25
62 11da Figura
61 67 334.
33 2
ordenao

16 passos
16

0 2 11 12 25 26 30 33 54 59 61 62 67 72 73 98
Figura 334: Passos para ordenao por intercalao

Ali vemos o processo ilustrado para um vetor cujo tamanho uma potncia de 2, mas para
outros tamanhos, podemos considerar como limite superior a complexidade exigida para a
menor potncia de 2 que supere o tamanho do vetor. Vamos considerar apenas a fase de
intercalao, ilustrada na parte inferior da figura, uma vez que as divises so feitas com
pouco trabalho computacional. Repare que:

para a ltima intercalao realizada, que gera o vetor ordenado de tamanho a partir
de dois vetores ordenados de tamanho
, so feitas no operaes.
para cada intercalao no penltimo nvel, que geram vetores ordenados de tamanho
a partir de vetores de tamanho
, so feitas no
operaes; como temos
duas intercalaes neste nvel, teremos tambm no mximo comparaes.
o mesmo vale para todos os nveis anteriores; como temos
nveis, o nmero
mximo de comparaes realizadas pelo algoritmo de ordenao por intercalao
igual a
, e o algoritmo portanto
.

Para se ter uma idia da diferena de desempenho entre os algoritmos de seleo e troca e de
intercalao, quando
,
,e
; quando
,
,e
, e por a vai.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Algoritmos

177

Figura 335: Grfico de desempenho para a funo MergeSort

A Figura 335 mostra o resultado de testes de desempenho realizados com a funo


MergeSort. interessante comparar este grfico com o da Figura 328. Em 20 segundos, a
funo SelectSort, executada em um computador com desempenho superior, foi capaz de
ordenar um vetor de 4000 elementos; com este mesmo tempo, a funo MergeSort,
executada em um computador com desempenho inferior, conseguiu ordenar um vetor com
mais de 35000 elementos.
4.3.3

Partio (QuickSort)

Outro mtodo para se ordenar um vetor utiliza uma operao de partio do vetor segundo
um piv, que um valor igual a um dos elementos do vetor. A partio, aplicvel somente a
vetores com dois ou mais elementos, separa o vetor em trs partes:

a da esquerda, contendo somente elementos menores ou iguais ao piv,


a do meio, contendo somente elementos iguais ao piv, e
a da direita contendo somente elementos maiores ou iguais ao piv.

possvel que algumas das partes resultantes seja vazia. O mtodo prossegue aplicando-se
recursivamente s parties da esquerda e da direita, at se conseguir parties de tamanho 1
que esto trivialmente ordenadas. Este um dos algoritmos mais famosos da cincia da
computao, tendo recebido o nome de quicksort.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Algoritmos

178
14 0

11 6

11 12 14 12 13 6

11 12 6

12 13 14

11 12 6

12 13 14

12 11 12 13 14

11 12 12 13 14

11 12 12 13 14

12 2

12 13 6

Esquerda
Meio
Direita
x Piv

Figura 336: Exemplo de ordenao por partio (quicksort)

A Figura 336 ilustra o comportamento do algoritmo na ordenao de um vetor com 10


elementos. A cada partio o piv escolhido est sublinhado.
function sA = quicksort(A)
if length(A) <= 1 then
sA = A;
else
[l,m,r] = partition(A);
sA = [quicksort(l) m quicksort(r)];
end
endfunction
Figura 337: A funo quicksort, que implementa o algoritmo de ordenao por partio

Assim como o algoritmo de intercalao, a implantao do quicksort por meio de uma funo
recursiva uma expresso direta do algoritmo, como mostra a Figura 337. As parties so
feitas pela funo partition, mostrada na Figura 338.
function [left,middle,right] = partition(A)
pivot = A((1+int(length(A))/2));
inf = 1;
sup = length(A);
while sup >= inf
while A(inf) < pivot
inf = inf+1;
end
while A(sup) > pivot
sup = sup-1;
end
if sup >= inf then
temp = A(inf); A(inf) = A(sup); A(sup) = temp;
inf = inf+1; sup = sup-1;
end
end
left = A(1:sup); middle = A(sup+1:inf-1);
right = A(inf:length(A));
endfunction
Figura 338: A funo partition

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Algoritmos

179

Diversos pontos so dignos de nota nesta funo:

O piv escolhido como o elemento posicionado ao meio do vetor A. Isto no um


requisito do algoritmo, que entretanto exige que o piv seja um dos elementos de A.
Algumas verses escolhem o primeiro elemento do vetor como piv, enquanto outras
sorteiam a sua posio;
inf mantido de forma tal que, a qualquer momento, todos os elementos sua
esquerda so menores ou iguais ao piv. Repare que isto vlido inicialmente, pois
no existe nenhum elemento sua esquerda, e que mantido vlido por todos os
comandos;
sup mantido de forma tal que, a qualquer momento, todos os elementos sua
direita so maiores ou iguais ao piv; a argumentao para esta afirmativa anloga
empregada para a varivel inf;
inf avana sempre para a direita, e sup para a esquerda; o loop principal para
quando estes dois ponteiros se cruzam;
no primeiro loop interno, inf avana para a direita at encontrar um elemento com
valor maior ou igual ao piv;
no segundo loop interno, sup avana para a esquerda at encontrar um elemento
com valor menor ou igual ao piv;
os elementos encontrados nestes dois loops internos so trocados de posio, a no
ser que inf e sup j tenham se cruzado;

No difcil ver que a funo partition realiza comparaes para dividir uma partio de
tamanho . O comportamento do algoritmo de ordenao por partio fortemente
dependente das escolhas de piv. No melhor caso, os pivs escolhidos so tais que cada
partio divide o vetor ao meio e, por motivos similares aos colocados na anlise da
complexidade do algoritmo de ordenao por intercalao, o quicksort
. No pior
caso, o piv tal que cada partio produz uma parte com um nico elemento e outra com
elementos, e o nmero de comparaes
, to ruim como a ordenao por
seleo e troca.
4.3.4

Dividir para Conquistar

Os algoritmos de ordenao por intercalao e por partio so exemplos de emprego de uma


estratgia clssica em computao, chamada dividir para conquistar. Dado um problema de
tamanho ,

o problema dividido em 2 subproblemas de tamanho


(ou 3 subproblemas de
tamanho
, ou ...);
cada subproblema conquistado por aplicao recursiva da mesma estratgia, a no
ser que o seu tamanho seja suficientemente pequeno para permitir uma soluo
direta;
as solues dos subproblemas so combinadas para resolver o problema original.

Na ordenao por intercalao a diviso em subproblemas simples, mas a combinao das


solues dos subproblemas exige a intercalao. Na ordenao por partio a diviso em
subproblemas exige a execuo do algoritmo de partio, mas a combinao das solues dos
subproblemas consiste apenas em sua justaposio.

4.4 Algoritmos Numricos


Nesta seo ns vemos algoritmos numricos para o clculo de integrais definidas e tambm
para encontrar razes de uma funo
. Tais algoritmos tm utilidade para problemas cuja
soluo analtica difcilmente obtida ou no existe. Ns desenvolvemos tambm uma funo
para o clculo da srie de Taylor para , clculo que est sujeito a problemas que podem
Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Algoritmos

180

resultar de operaes de truncamento e de arredondamento que decorrem do uso de um


nmero finito de bits na representao de ponto flutuante.
4.4.1

Integrao por Trapzios

O primeiro passo para se obter uma aproximao numrica de uma integral


diviso do intervalo
em subintervalos iguais.Com isso ns vamos obter
regularmente espaados, que vamos chamar de
. Ns temos
e
, para todo
.

,
O lado direito de
cada retngulo
coincide com a
curva

O lado esquerdo
de cada retngulo
coincide com a
curva

rea =
f(xi+1).x

rea =
f(xi).x
xi

a
pontos

xi+1

xi

Figura 339: reas cobertas pelas somas de Riemann pela esquerda e pela direita para
[0,1]

xi+1

no intervalo

A Figura 339 mostra duas formas de se aproximar do valor da integral utilizando somas das
reas de retngulos, conhecidas como soma de Riemann pela esquerda e soma de Riemann
pela direita. Podemos ver que a rea definida pela soma de Riemann pela esquerda dada por

enquanto a rea definida pela soma de Riemann pela direita dada por

A medida em que o nmero de intervalos aumenta e o tamanho do intervalo diminui, as


somas de Riemann vo se aproximando da rea sob a curva, como mostra a

Figura 340: Somas de Riemann com 16 intervalos

As frmulas das somas de Riemann levam diretamente s suas implementaes, mostradas na


Figura 341 e na Figura 342.
Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Algoritmos

181

function lrs = LeftRiemannSum(f,a,b,n)


// Calcula a soma de Riemann esquerda da funo
// f entre os pontos a e b com n intervalos
x = linspace(a,b,n+1);
delta_x = (b-a)/n;
lrs = sum(f(x(1:n))) * delta_x;
scf();
plot2d2(x,f(x),style=5,axesflag=5);
plot2d3(x,f(x),style=5,axesflag=5);
xx=linspace(a,b,50);
plot2d(xx,f(xx));
endfunction
Figura 341: Funo para o clculo da soma de Riemann esquerda

function rrs = RightRiemannSum(f,a,b,n)


// Calcula a soma de Riemann direita da funo
// f entre os pontos a e b com n intervalos
x = linspace(a,b,n+1);
delta_x = (b-a)/n;
rrs = sum(f(x(2:n+1)))* delta_x);
scf();
plot2d2(x,[f(x(2:n+1)) f(b)],style=5,axesflag=5);
plot2d3(x,[f(x(2:n+1)) f(b)],style=5,axesflag=5);
xx=linspace(a,b,50);
plot2d(xx,f(xx),axesflag=5);
endfunction
Figura 342: A funo RightRiemannSum

Nestas funes, voc pode observar que:

O primeiro parmetro de entrada, f, a funo cuja soma de Riemann ser calculada;


Os parmetros a e b so os extremos do intervalo, e n o nmero de sub-intervalos;
A funo sum do Scilab utilizada para o clculo da soma dos elementos de um vetor;
Para o clculo das somas somente os trs primeiros comandos so necessrios; os
comandos restantes se destinam ao desenho de um grfico que ilustra a soma
realizada.

No difcil ver que possvel obter uma aproximao melhor da rea sob a curva em um subintervalo se utilizarmos o trapzio definido pelo valor da funo em seus limites, cono
mostrado na Figura 343.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Algoritmos

182

rea do sub-intervalo =
x.(f(xi) + f(xi+1))/2

xi

xi+1

Figura 343: Aproximao por trapzios

A soma das reas dos trapzios dada por

ou

ou

Uma funo que calcula uma integral por trapzios est mostrada na Figura 344.
function area = TrapezoidalSum(f,a,b,n)
// Calcula a rea sob a curva f entre a e b,
// utilizando n intervalos e a frmula dos
// trapzios
x = linspace(a,b,n+1);
delta_x = (b-a)/n;
area = ( (f(x(1))+f(x(n+1)))/2 + ...
sum(f(x(2:n))) ...
)*delta_x;
scf();
plot2d(x,f(x),style=5,axesflag=5)
plot2d3(x,f(x),style=5,axesflag=5);
xx=linspace(a,b,50);
plot2d(xx,f(xx),axesflag=5);
endfunction
Figura 344: Funo para aproximao de integrais por trapzios

Para testar esta funo, vamos calcular


, cujo valor exato ns sabemos que igual
a 2. Com 5 intervalos, o resultado da chamada TrapezoidalSum(sin,0,%pi,5) foi
1.9337656; com 50 intervalos (chamada TrapezoidalSum(sin,0,%pi,50)), o valor
obtido foi 1.999342.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Algoritmos
4.4.2

183

Bisseo

Ns sabemos que as razes (ou zeros) de funes como um polinmio de 2 grau podem ser
encontradas por frmulas analticas, mas isto no possvel para muitas outras funes. O
mtodo da bisseo um algoritmo que serve para determinar numericamente uma raiz de
uma equao
, onde
uma funo contnua qualquer. Para dar incio ao
algoritmo, precisamos de dois pontos e , sendo
, onde a funo assume sinais
opostos, ou seja, ou bem
e
, ou ento
e
, como
mostrado na Figura 345.

Figura 345: Exemplos de intervalos adequados para o mtodo da bisseo

Como a funo contnua, e como


no intervalo
ns teremos
uma raiz, como na Figura 346.

tm sinais opostos, em pelo menos um ponto


. possvel que o intervalo
contenha mais de

Figura 346: Intervalo contendo mais de uma raiz de uma funo

Se
e
tm o mesmo sinal, o intervalo
mostra a Figura 347.

pode conter ou no uma raiz, como

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Algoritmos

184

Figura 347: Intervalos em que a funo no tem sinais opostos nos extremos podem conter ou no uma raiz

Se
no for contnua, possvel que mesmo com
sinais opostos) no exista nenhuma raiz no intervalo

(ou seja,

tm

Figura 348: Se a funo no for contnua, sinais opostos nas extremidades de um intervalo no garantem que ele
contenha uma raiz

O mtodo da bisseo exige portanto que


seja contnua em um intervalo
tal que
. De uma forma similar ao algoritmo de pesquisa binria, a cada iterao a
funo calculada no ponto mdio do intervalo,
.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Algoritmos

185

Figura 349: Caso em que a raiz est " esquerda" do ponto mdio do intervalo

Temos trs casos possveis. No primeiro (Figura 349) verificamos que


,e
portanto que o intervalo
contm pelo menos uma raiz, onde o algoritmo pode ser
reaplicado.

Figura 350: Caso em que a raiz est " direita" do ponto mdio do intervalo

No segundo caso (Figura 350) temos


menos uma raiz.

, e o intervalo

A terceira possibilidade de termos tido sorte e encontrado

tal que

que contm pelo


.

Ao fim de cada iterao, ou bem a raiz foi encontrada, ou o intervalo de busca foi reduzido
metade. O algoritmo consiste na aplicao repetida deste passo, e termina quando o intervalo
onde se encontra a raiz suficientemente pequeno para a preciso desejada.
Podemos agora dar incio ao desenvolvimento de uma funo que encontre uma raiz de uma
outra funo dada pelo mtodo da bisseo.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Algoritmos

186

function r = bissecao(f,a, b, tol)


//
se f contnua e se f(a).f(b) < 0, esta
//
funo calcula a raiz r com preciso menor ou igual
//
ao valor de tol
endfunction
Figura 351: Cabealho da funo bissecao

A Figura 351 mostra uma primeira verso da funo bissecao contendo apenas o seu
cabealho:

O primeiro parmetro formal de entrada, f, a funo da qual se deseja encontrar a


raiz;
Os parmetros a e b so os limites do intervalo, e devem ser tais que f(a)*f(b) <
0;
O parmetro tol a tolerncia, isto , um valor para o tamanho do intervalo de busca
onde a preciso desejada considerada satisfatria;
O parmetro de sada r a raiz encontrada.

Para testar a funo bissecao, ns precisamos:

de uma funo contnua,


de um intervalo onde a funo troca de sinal,
e de conhecer o valor de uma raiz nesse intervalo para que seja possvel verificar o
resultado.

b
a
Figura 352: Grfico de

A funo
requisitos, pois:

, cujo grfico est mostrado na Figura 352, satisfaz a estes

contnua;
tem sinais opostos nos extremos do intervalo
uma raiz, e
esta raiz .

, e portanto este intervalo contm

A Figura 353 mostra uma implementao desta funo. Repare no uso do operador .*, de
multiplicao elemento a elemento, ao invs do operador *, de multiplicao matricial.
function y = exp_sin(x)
y = exp(-x) .* sin(x);
endfunction
Figura 353: A funo exp_sin

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Algoritmos

187

O grfico da Figura 352 pode ser obtido na console do Scilab com os comandos mostrados na
Figura 354. A diretiva axesflag=5 faz com que os eixos sejam traados no ponto (0,0).
-->getf("exp_sin.sci")
-->x = linspace(0,2*%pi,101);
-->y = exp_sin(x);
-->plot2d(x,y,axesflag=5)
Figura 354: Comandos para obter o grfico da Figura 352 na console do Scilab

Com isso ns j podemos construir um programa testador para a funo bissecao, conforme
mostra a Figura 355. O programa permite experimentar com diversos valores de tolerncia,
comparando a raiz calculada com o valor de com 10 casas decimais.
clear
getf("exp_sin.sci");
getf("bissecao.sci");
tolerancia = input("\nTolerncia = ");
while tolerancia > 0
raiz = bissecao(exp_sin,2,4, tolerancia);
printf(" Raiz = %12.10f; \n
Pi = %12.10f\n",raiz,%pi);
tolerancia = input("\nTolerncia = ");
end
Figura 355: O programa bissecao_teste.sce

Um primeiro refinamento da funo bissecao.sci o loop que, a cada passo, reduz


metade o intervalo que contm a raiz. Na Figura 356 ns podemos observar que:

o loop interrompido quando o tamanho do intervalo menor ou igual tolerncia


fornecida pelo usurio, e
o valor retornado como raiz o ponto mdio do intervalo.
function r = bissecao(f,a, b, tol)
//
se f contnua e se f(a).f(b) < 0, esta
//
funo calcula a raiz r com preciso menor ou igual
//
ao valor de tol
while b-a > tol
// Reduo do intervalo que contm a raiz
end
r = (a+b)/2;
endfunction
Figura 356: Primeiro refinamento da funo bissecao

O refinamento da reduo do intervalo simplesmente a codificao do mtodo da bisseo,


como mostra a Figura 357. Repare que:

quando f(a)*f(m) < 0, a funo faz b = m;


quando f(b)*f(m) < 0, a funo faz a = m;
quando f(m) == 0, a funo faz a = m e b = m.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Algoritmos

188

function r = bissecao(f,a, b, tol)


//
se f contnua e se f(a).f(b) < 0, esta
//
funo calcula a raiz r com preciso menor ou igual
//
ao valor de tol
while b-a > tol
// Reduo do intervalo que contm a raiz
m = (a+b)/2; //Ponto mdio
if f(a)*f(m) <= 0 then
// [a,m] contm uma raiz
b = m;
end
if f(m)*f(b) <= 0 then
// [m,b] contm uma raiz
a = m;
end
end
r = (a+b)/2;
endfunction
Figura 357: A funo bissecao

A Figura 358 mostra o resultado de um teste da funo bissecao, onde podemos ver o efeito
da tolerncia fornecida pelo usurio sobre a preciso do clculo da raiz.
Tolerncia = 1.0e-3
Raiz = 3.1411132813;
Pi = 3.1415926536
Tolerncia = 1.0e-6
Raiz = 3.1415925026;
Pi = 3.1415926536
Tolerncia = 1.0e-10
Raiz = 3.1415926536;
Pi = 3.1415926536
Figura 358: Teste da funo bissecao

4.4.3

Srie de Taylor para exp(x) e Cancelamento Catastrfico

Do clculo sabe-se que, para qualquer real, pode ser calculado por uma srie de Taylor,
que uma soma de infinitos termos com a forma abaixo:
,
ou, lembrando que

Esta srie converge para qualquer valor de . Ns podemos ver que, a partir do termo onde
, cresce mais rapidamente que , e que o valor absoluto dos termos tende para zero.
Queremos aqui construir uma funo Scilab que calcule
por esta frmula, adicionando
termos at que seu valor absoluto seja menor que uma tolerncia fornecida pelo usurio. J
temos como escrever o cabealho da funo, como mostra a Figura 359.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Algoritmos

189
function y = expTaylor(x,tol)
// Calcula a soma dos termos
// da srie de Taylor at o primeiro
// termo com valor absoluto menor
// que a tolerncia tol
endfunction
Figura 359: Cabealho da funo expTaylor

Para testar esta funo, o programa expTaylor_teste, mostrado na Figura 355, l um


valor para a tolerncia. Depois, repetidamente, l valores para a varivel x, calcula e compara
os valores retornados pela funo expTaylor que ns desenvolvemos e pela funo exp
fornecida pelo Scilab, que bastante confivel pois utiliza tcnicas muito sofisticadas de
clculo numrico.
getf("expTaylor.sci");
tol = input("\ntol = ");
x = input("\nx = ");
while x ~= 999
expCalc = expTaylor(x,tol);
printf("\n
x
exp(x)
expTaylor(x)
printf ("\n%12g %15.8e %15.8e %15.8e\n", ...
x,exp(x),expCalc,exp(x)-expCalc)
x = input("\nx = ");
end

Erro")

Figura 360: O programa expTaylor_teste.sce

Para o desenvolvimento da funo expTaylor, ns devemos reparar que possvel obter ,


o -simo termo da srie a partir do termo anterior, pois

Com isso ns chegamos forma final da funo expTaylor, mostrada na Figura 361.
function y = expTaylor(x,tol)
// Calcula a soma dos termos
// da srie de Taylor at o primeiro
// termo com valor absoluto menor
// que a tolerncia tol
Termo = 1;
y = 1;
i = 1;
while abs(Termo) >= tol
Termo = Termo * x / i;
y = y + Termo;
i = i+1;
end
endfunction
Figura 361: A funo expTaylor

Vamos primeiramente testar a funo para alguns valores positivos de x. Podemos ver na
Figura 362 que os resultados so muito bons, com diferenas 16 ordens de grandeza menores
que os valores calculados pelas duas funes.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Algoritmos

190

tol = 1.0e-40
x = 1
1 2.71828183e+000 2.71828183e+000 -4.44089210e-016
x = 10
10 2.20264658e+004 2.20264658e+004 7.27595761e-012
x = 30
30 1.06864746e+013 1.06864746e+013 -3.90625000e-003
Figura 362: Resultados de testes da funo expTaylor com x positivo

Mas o teste com valores negativos nos reserva surpresas desagradveis, como mostra a Figura
363. Para x == -1, o erro inferior aos valores por 15 ordens de grandeza, muito bom. Para
x == -10, o erro 8 ordens de grandeza menor que os valores calculados; v l. J com x
== -20, o erro da mesma ordem de grandeza dos valores calculados, muito ruim. A casa cai
mesmo com x==-30, quando o erro 9 ordens de grandeza maior que o valor correto, e,
pior, o valor calculado para
negativo, sendo que uma funo estritamente
positiva!
tol = 1.0e-40
x = -1
-1 3.67879441e-001 3.67879441e-001 -1.11022302e-016
x = -10
-10 4.53999298e-005 4.53999296e-005 1.39453573e-013
x = -20
-20 2.06115362e-009 5.62188447e-009 -3.56073085e-009
x = -30
-30 9.35762297e-014 -3.06681236e-005 3.06681237e-005
Figura 363: Resultados de testes da funo expTaylor com x negativo

O que aconteceu? A frmula para a srie de Taylor provada matematicamente, e a funo


expTaylor uma implantao direta da frmula, com pouca possibilidade de erros.

-->eps = 1.0e-23;
-->y = 1.0e23;
-->x = y + eps;
-->x == y
ans =
x igual a y bit por bit!
T
Figura 364: Exemplo de cancelamento catastrfico

A origem dos maus resultados est na aritmtica de ponto flutuante, que usa um nmero fixo
de bits para representao da mantissa. Operaes aritmticas com nmeros com grandes
diferenas de ordem de grandeza no funcionam corretamente, como mostra a Figura 364.
O valor 1.0e-23 somado a 1.0e23 no altera o seu expoente, o que natural, mas
tampouco altera a sua mantissa, que no possui bits suficientes para essa adio. O valor
somado simplesmente perdido na operao, em um efeito que conhecido por
cancelamento catastrfico.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Algoritmos

191

~4.3e007
15 ordens de
grandeza maior
que o resultado
correto

Figura 365: Grfico com valores absolutos dos termos da srie de Taylor para x == -20

A Figura 365 mostra um grfico com os valores absolutos dos termos da srie de Taylor para x
== -20. O maior valor absoluto de um termo da ordem de
, e o valor correto para
da ordem de
. Ou seja, nas operaes aritmticas realizadas com os primeiros termos
da srie os erros de truncamento podem ser bem maiores que o resultado final, e isso o que
ocorre com o uso da funo expTaylor para o clculo de exponenciais de nmeros
negativos.
Como lio a tirar destes exemplos, voc deve ter muito cuidado ao operar com nmeros de
valores com grandes diferenas de ordem de grandeza. A aritmtica de ponto flutuante
melindrosa; use funes de bibliotecas, desenvolvidas por profissionais de clculo numrico,
sempre que possvel. Por outro lado, no se deixe levar pelo pessimismo. Programas
numricos funcionam como esperado na maior parte dos casos.

4.5 Barreiras de Complexidade


Ns vimos que o tempo necessrio para ordenar um vetor de tamanho cresce com
para o
algoritmo de ordenao por seleo de troca, e cresce com
para o algoritmo de
ordenao por intercalao. Existiriam algoritmos com curvas de crescimento melhores do que
o MergeSort? Seria possvel descobrir um algoritmo de ordenao que seja, digamos,
?
A resposta a esta pergunta negativa. Resultados tericos provam que o limite inferior para a
complexidade de qualquer algoritmo de ordenao
. Ou seja, existem resultados
de complexidade associados a problemas, vlidos para qualquer algoritmo. No restante desta
seo ns iremos expor alguns resultados muito importantes relacionados com a
complexidade de problemas.
4.5.1

Problemas np-completos: O Problema do Caixeiro Viajante

Um caixeiro viajante precisa visitar cidades, percorrendo a menor distncia possvel, sem
passar duas vezes pela mesma cidade. Ele conhece a distncia entre duas cidades quaisquer de
seu roteiro; um exemplo est mostrado na Figura 366. No existem estradas entre as cidades
sem ligao no grafo.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Algoritmos

192
1
2

6
5

3
3
3

4
3
7

Figura 366: Distncias entre cidades a serem visitadas pelo caixeiro viajante

Qual o melhor roteiro, isto , qual o roteiro com a menor distncia total, partindo da
cidade 1? Na Figura 367 voc pode ver como a escolha de um roteiro influencia a distncia
total.
1

1
2

6
5

1
2

6
2

3
3

3
3

3
7

3
3

D = 19

D = 22

D = 15

Figura 367: Algumas alternativas de roteiros para o caixeiro viajante

Um exame atento nos faz perceber que o roteiro mais direita na Figura 367 , dentre todos,
o de menor custo. Descobrir o roteiro timo fica bem mais complicado quando temos mais
cidades, como na Figura 368.
1
8
14

12 9

11
13

10

12

15

15

12

11
6

12

12
3

6
5

Figura 368: Um problema com 8 cidades

Temos muito mais alternativas a examinar; trs exemplos esto na Figura 369. Aqui tambm a
alternativa mais direita a rota tima, fato que no fcil de se confirmar por um simples
exame do problema. Precisamos do auxlio de um computador. Queremos construir um
programa que, dado um conjunto de cidades e suas distncias, descubra o melhor roteiro para
o caixeiro viajante.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Algoritmos

193

8
8

14

11

12 9

13

10

12

12

15

12

4
4

6
5

12 9

11
13

10

12

12
3

D = 81

14

6
5

12 9

11
13

10

11
6

12

12

15

15

11
12

14

15

12

15

15

12

11
6

12

12
3

D = 98

6
5

D = 64

Figura 369: Algumas alternativas de roteiros para o problema da Figura 368

Vamos tentar uma soluo direta. Devemos:


1. Gerar todas as alternativas de roteiros;
2. Para cada roteiro, calcular o seu custo total;
3. Escolher o roteiro com menor distncia total.
E como fazer para gerar todas as alternativas de roteiros? Temos que gerar todas as
permutaes das cidades a serem percorridas. Para um problema com 4 cidades, as rotas a
serem examinadas so (lembrando que a cidade 1 o ponto inicial, e portanto faz parte de
qualquer circuito):
2

Ns iremos precisar de uma funo que gere as permutaes de um conjunto de nmeros,


cada nmero correspondendo a uma cidade. Vamos primeiramente definir um cabealho para
uma funo permutations (Figura 370).
Function p = permutations(A)
// gera uma matriz p onde
// cada linha uma permutao de A
endfunction
Figura 370: Cabealho da funo permutations

Precisamos agora de um algoritmo para gerar essas permutaes. O raciocnio , mais uma
vez, recursivo:

Se o vetor A de tamanho 1, ele j a nica permutao possvel;


seno, devemos separar o primeiro elemento do vetor;
gerar todas as permutaes dos elementos restantes (mesmo problema inicial, mas
com um elemento a menos), e fazer uma justaposio do elemento separado com as
permutaes obtidas;
repetir este procedimento para os demais elementos do vetor.

Como exemplo, considere o processo de gerar todas as permutaes do vetor [2 3 4]. Ns


devemos:
Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Algoritmos

194

Separar o elemento 2, e gerar todas as permutaes do vetor [3 4]; depois, concatenar


2 s permutaes obtidas;
Separar o elemento 3, e gerar todas as permutaes do vetor [2 4]; depois, concatenar
3 s permutaes obtidas;
Finalmente, separar o elemento 4, e gerar todas as permutaes de [2 3], e depois
concatenar 4 s permutaes obtidas.

A funo permutations mostrada na Figura 371 uma implementao direta deste


algoritmo.
function p = permutations(A)
if length(A) == 1 then
p = A;
else
p = [];
for i = 1:length(A)
B = permutations(OneOut(A,i));
[nl,nc] = size(B);
for j = 1:nl
p = [p ; [A(i) B(j,:)]];
end
end
end
endfunction
function b = OneOut(A,i)
x = 1:length(A);
b = A(x ~= i);
endfunction
Figura 371: A funo permutations

Ela faz uso da funo OneOut, que implementa a operao de separar o i-simo elemento
do vetor, e que um bom exemplo de uso das possibilidades oferecidas pelo Scilab para
manipulao de matrizes apresentadas na Seo 3.2.9 (pg. 138).
J podemos dar incio ao desenvolvimento do programa principal. A Figura 372 apresenta uma
primeira verso, formada apenas por comentrios.
//
//
//
//
//

L a matriz de distncias
Gera todas as rotas possveis
Calcula o custo de cada rota
Seleciona a de menor custo
Imprime o resultado

Figura 372: Primeira verso do programa CaixeiroViajante.sce

Vamos atacar inicialmente a leitura da matriz de distncias. Queremos utilizar a funo


fscanfMat para esta leitura, mas temos que levar em conta que:

precisamos representar o valor infinito para distncias entre cidades sem conexo
direta, e
a funo fscanfMat s l nmeros.

Isto pode ser resolvido adotando a conveno de usar no arquivo de entrada o valor -1 para
representar infinito. Com isto podemos construir um arquivo de distncias como mostra a
Figura 373.
Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Algoritmos

195

Figura 373 : Arquivo Distancias.txt com distncias entre as cidades mostradas na Figura 366

Este arquivo pode ser lido diretamente com fscanfMat. Aps a leitura, os elementos com
valor -1 devem ser substitudos por %inf. Voc pode ver este cdigo na Figura 374, onde
est destacado o comando que faz as substituies.
// L a matriz de distncias
Dist = ...
fscanfMat(uigetfile("*.txt",pwd(),"Distncias"));
// Substitui -1 por %inf
Dist(Dist==-1) = %inf;
Figura 374: Leitura do arquivo com distncias

Para gerar as rotas e calcular seus custos, vamos usar a funo permutations da Figura
371, e tambm uma funo cost, que recebe como parmetros de entrada uma matriz D de
distncias, e um vetor path, que contm os ndices das cidades que compem uma rota.
[nl,nc] = size(Dist); //nl deve ser igual a nc
Rotas = permutations(2:nc);
[NL,NC] = size(Rotas);
for i = 1:NL
Custo(i) = cost(Dist,[1 Rotas(i,:) 1]);
end
function c = cost(D,path)
c = 0;
for i=1:length(path)-1
c = c + D(path(i),path(i+1));
end
endfunction
Figura 375: Obteno de todas as rotas e clculo dos custos

Nos trechos de cdigo mostrados na Figura 375 voc deve reparar que:

o vetor Rotas recebe todas as permutaes das cidades de 2 a n, e no de 1 a n, pois


a cidade 1 sempre o ponto de partida e de chegada.
a rota enviada (passada como parmetro real) para a funo cost o vetor formado
pela cidade 1 acrescida das cidades que compem uma linha do vetor Rotas,
acrescido novamente pela cidade 1.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Algoritmos

196

// Resolve o problema do caixeiro viajante


clear()
getf("permutations.sci");
getf("cost.sci");
getf("OneOut.sci");
getf("SelecionaMenor.sci");
getf("PrintMatrix.sci");
// L a matriz de distncias
Dist = fscanfMat(uigetfile("*.txt",pwd(),"Distncias"));
PrintMatrix("Distncias",Dist);
// Substitui -1 por %inf
Dist(Dist==-1) = %inf;
// Obteno das rotas
[nl,nc] = size(Dist); //nl deve ser igual a nc
Rotas = permutations(2:nc);
// Calcula o custo de cada rota
[NL,NC] = size(Rotas);
for i = 1:NL
Custo(i) = cost(Dist,[1 Rotas(i,:) 1]);
if Custo(i) <> Exemplos(:,1) then
end
end
// Seleciona a de menor custo
Melhor = SelecionaMenor(Custo,1);
// Imprime a melhor rota
printf("\nA melhor rota ");
PrintMatrix("Rota",[1 Rotas(Melhor,:) 1]);
printf("com custo total = %d.",Custo(Melhor));
Figura 376: O programa CaixeiroViajante.sce

A Figura 376 mostra o programa completo, que tambm usa as funes SelecionaMenor
(Figura 324, pgina 171) e PrintMatrix (Figura 325, pgina 171). Executando este
programa com o arquivo Distancias.txt (Figura 373), ns vemos que a melhor rota [1 2 3 5
4 1] com custo total = 15, mostrada na Figura 367.
Muito bem, temos um programa que resolve o problema do caixeiro viajante. Mas ser que
com ele ns poderemos encontrar o melhor roteiro para visitar de avio todas as 27 capitais
brasileiras? melhor nem tentar. Com cidades, temos
permutaes a explorar.
Para o exemplo com 5 cidades, so
possibilidades, fcil. Para 8 cidades, temos
rotas a examinar, sem problemas, mas para as capitais brasileiras, so
permutaes a serem examinadas!

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Algoritmos

197

Figura 377: Qual o melhor roteiro para visitar as 27 capitais brasileiras?

Mas isso no seria simplesmente um defeito do nosso algoritmo, cuja complexidade


?
Infelizmente no. Efetivamente existem solues melhores, com tcnicas mais sofisticadas que
reduzem o nmero de roteiros a serem examinados. Mas no reduzem tanto. A melhor
soluo j encontrada tem complexidade
, o que para suficientemente grande
cresce mais rapidamente do que qualquer potncia de , ou do que qualquer polinmio em .
O caixeiro viajante um exemplo da classe de problemas conhecidos como np-completos,
onde np significa tempo polinomial no-determinstico. As razes para esta denominao
esto acima da abrangncia deste texto. Outro exemplo de problema np-completo o
problema da mochila, que consiste em descobrir qual a melhor escolha a de maior valor
total de objetos com pesos e valores a serem colocados em uma mochila que tem uma
capacidade mxima que no pode ser ultrapassada.

Figura 378: Quais objetos devem ser colocados na mochila para se obter o maior valor total sem que o peso total
ultrapasse a capacidade da mochila?

Um problema aberto da computao a existncia ou no de uma soluo com complexidade


polinomial para os problemas np-completos. At hoje, ningum conseguiu provar que no
existe nenhuma soluo com tempo polinomial e, por outro lado, ningum conseguiu um
algoritmo com complexidade polinomial para resolver qualquer problema np-completo.
Portanto, se voc conseguir desenvolver um algoritmo com complexidade polinomial para
resolver o problema do caixeiro viajante ou o da mochila, ou provar que no existe tal soluo,
voc ficar famoso.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Algoritmos
4.5.2

198

Problemas indecidveis: O Problema da Correspondncia de Post

Vamos agora estudar um problema proposto pelo matemtico Emil Post em 1946. Considere
um estoque ilimitado de domins de um nmero finito de tipos.
Tipo 1
100

Tipo 2
0

Tipo 3
1

100

00

Figura 379: Exemplo de domins para o problema da Correspondncia de Post

Todos os domins de um tipo tm um mesmo string de 0s e 1s na parte de cima e outro na


parte de baixo. O problema da correspondncia de Post resolvido se voc encontrar uma
seqncia de domins tal que os strings formados pela concatenao dos strings superiores e
inferiores sejam iguais. A Figura 380 mostra uma soluo para o problema proposto na Figura
379.

100

100

00

100

100

100

00

00

100

100

1001100100100
Figura 380: Uma soluo com 7 domins

Vamos representar uma sequncia de domins por um vetor de ndices como [1 3 1 1 3 2 2],
que significa um domin do tipo 1, seguido de um domin do tipo 3, seguido de dois do tipo
1, seguido de um domin do tipo 2, seguido por dois do tipo 2.
Para resolver o problema de Post ns vamos novamente usar um algoritmo fora-bruta, que
gera todas as sequncias possveis de domins, comeando pelas menores. Se tivermos 3 tipos
de domins, as primeiras sequncias geradas so [1], [2], [3], [1 1], [1 2], [1 3], [2 1], [2 2], [2
3], [3 1], [3 2], [3 3], [1 1 1], [1 1 2], [1 1 3], [1 2 1], e assim por diante. Voc pode ver que a
gerao das sequncias pode ser feita por um processo equivalente contagem em um
sistema de base 3, sem o algarismo 0 e incluindo o algarismo 3.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Algoritmos

199
getf("ReadPostProblem.sci");
getf("Sucessor.sci");
getf("strPost.sci");
getf("WritePostSolution.sci");
getf("WritePostProblem.sci");
// Leitura do problema de Post
[nTypes Up Down] = ReadPostProblem();
WritePostProblem(Up,Down);
found = %f;
seq = [];
while ~found
seq = Sucessor(seq,nTypes);
upString = strPost(Up,seq);
dnString = strPost(Down,seq);
found = upString == dnString;
if found then
WritePostSolution(seq,Up,Down);
end
end
Figura 381: O programa Post.sce

A Figura 381 mostra o programa Post.sce, aonde:

A funo ReadPostProblem usada para ler um problema de Post um conjunto


de tipos de domins. Essa funo retorna um inteiro nTypes, o nmero de tipos de
domins, e os vetores de strings Up e Down, que contero respectivamente os strings
da parte de cima e da parte de baixo de cada tipo de domin no problema lido;
A funo WritePostProblem imprime na tela os dados do problema lido;
O programa executa um loop que explora todas as seqncias de domins extrados
dos tipos lidos, parando se encontrar uma seqncia onde as concatenaes dos
strings da parte superior e da parte inferior dos domins so iguais.
A varivel seq contm uma seqncia de domins, que a cada passagem do loop
substituda por sua sucessora, usando a funo Sucessor;
A funo WritePostSolution usada para imprimir na tela uma soluo
eventualmente encontrada;
A funo strPost constri um string concatenando segundo uma sequncia dada os
strings na parte superior ou na parte inferior dos domins.

Figura 382: Tela do Bloco de Notas com um arquivo de tipos de domins para o problema de Post da Figura 379

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Algoritmos

200

Vamos comear pela leitura de um conjunto de tipos de domins. A Figura 382 ilustra o
formato que escolhemos para arquivos com tipos de domins que descrevem um problema de
Post.
function [nTypes, Up, Down] = ReadPostProblem()
PostFile = uigetfile("*.txt",pwd(),"Problema de Post");
da = mopen(PostFile,"r");
Lines = mgetl(da);
Up = tokens(Lines(1));
Down = tokens(Lines(2));
[nTypes,nc]=size(Up);
endfunction
Figura 383: A funo ReadPostProblem

A funo ReadPostProblem (Figura 383) faz uso da funo tokens, fornecida pelo Scilab,
que recebe um string como parmetro de entrada, e produz um vetor coluna, onde os
elementos do vetor so strings que, no string de entrada, esto separados por brancos ou
tabulaes.
function WritePostProblem(Up,Down);
printf("\nProblema de Post:\n");
[nl,nc] = size(Up);
for i = 1:nl
printf("%5s",Up(i));
end
printf("\n");
for i = 1:nl
printf("%5s",Down(i));
end
endfunction
Figura 384: A funo WritePostProblem

A funo WritePostProblem (Figura 384) imprime na tela um problema armazenado nos


vetores de strings Up e Down.
function s = strPost(Strs,seq)
s = "";
for i = 1:length(seq)
s = s + Strs(seq(i));
end
endfunction
Figura 385: A funo strPost

A Figura 385 mostra a funo strPost que constri a concatenao dos strings em uma
sequncia de domins.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Algoritmos

201
function s = Sucessor(r,nTypes)
// retorna o sucessor da sequncia r
VaiUm = 1;
for i = length(r):-1:1
if VaiUm > 0 then
if r(i) < nTypes then
r(i) = r(i) + 1;
VaiUm = 0;
else
r(i) = 1;
end
end
end
if VaiUm == 1 then
s = [1 r];
else
s = r;
end
endfunction
Figura 386: A funo Sucessor

A funo Sucessor (Figura 386) gera, a partir de uma seqncia de domins, a seqncia
seguinte no processo de contagem. Essencialmente ela soma 1 ao nmero formado pelos
algarismos que compem a seqncia. A Figura 387 mostra alguns exemplos de uso desta
funo.
-->Sucessor([],3)
ans =
1.
-->Sucessor([2 3 1],3)
ans =
2.
3.
2.
-->Sucessor([3 3 3],3)
ans =
1.
1.
1.
1.
Figura 387: Exemplos de uso da funo Sucessor

Finalmente temos a funo WritePostSolution (Figura 388) que imprime na tela a


soluo encontrada, em um formato tabular.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Algoritmos

202
function WritePostSolution(seq, Up, Down)
printf("\nSoluo: %s\n",strPost(Up,seq));
for i = 1:length(seq)
printf("%5d",seq(i))
end
printf("\n");
for i = 1:length(seq)
printf("%5s",Up(seq(i)));
end
printf("\n");
for i = 1:length(seq)
printf("%5s",Down(seq(i)));
end
endfunction
Figura 388: A funo WritePostSolution

J podemos testar o nosso programa para ver se encontramos a soluo da Figura 380.
Escolhendo como entrada o arquivo ProblemaPost.txt, vemos que o programa Post.sce
efetivamente resolve este problema, produzindo a sada mostrada na Figura 389.
Problema de Post:
100
0
1
1 100
00
Soluo: 1001100100100
1
3
1
1
3
100
1 100 100
1
1
00
1
1
00

2
0
100

2
0
100

Figura 389: Sada do programa Post.sce, alimentado com o arquivo da Figura 382.

Como voc j deve esperar, inferir desse primeiro sucesso que o nosso algoritmo resolve
qualquer problema de Post ingenuidade.
1000

01

00

101

001

Figura 390: A menor soluo para este problema de Post uma sequncia de 206 domins!

Usando algoritmos mais sofisticados, possvel mostrar que a menor seqncia que resolve o
problema da Figura 390 formada por 206 domins. Baseando-se em testes feitos pelo autor
destas linhas, o tempo estimado para o programa Post.sce resolver este problema com um
notebook seria de
anos!
Poderamos pensar que estamos diante de um problema como o do caixeiro viajante, mas
mesmo isso otimismo. A correspondncia de Post pertence a uma classe de problemas
chamados indecidveis. Enquanto em problemas np-completos o espao de busca cresce
explosivamente com o tamanho da entrada, em problemas indecidveis o espao de busca
simplesmente ilimitado. Traduzindo para o problema de Post, o fato de no existir nenhuma
seqncia de tamanho que resolva um dado problema no quer dizer que no existam
solues de tamanho maior que .
A indecidibilidade se refere ao caso geral, e no a instncias particulares. Para algumas
instncias, como nos casos da Figura 380 e da Figura 390, pode ser possvel encontrar uma
soluo. Para outras, pode ser possvel demonstrar que no existe nenhuma soluo, como
seria o caso de um problema onde em todos os domins o string da parte superior fosse mais
longo que o da parte inferior.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Algoritmos

203
10

001

001

Figura 391: Um problema de Post sem soluo conhecida.

Resultados tericos provam que no existe nenhum algoritmo que, para qualquer instncia de
um problema de Post, consiga decidir se existe ou no uma soluo. A Figura 391 mostra um
problema de Post para o qual no foi possvel, at hoje, nem encontrar uma soluo, e nem
tampouco provar que ele no admite nenhuma soluo.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Notas Finais e Prximos Passos

204

5 Notas Finais e Prximos


Passos
Chegamos ao fim de nosso curso, onde vimos alguns dos conceitos que constituem os pilares
da cincia da computao. hora de rever brevemente estas idias para obter uma viso de
conjunto, e tambm hora para apontar algumas direes para os prximos passos.

Computadores trabalham com informao, que pode ser digital (simblica) ou


analgica;
Um computador trabalha essencialmente com informao simblica, usando apenas
dois smbolos, comumente notados 0 e 1; equipamentos de entrada e sada utilizam
transformaes anlogo-digital ou digital-analgica quando conveniente.
Um bit a unidade de memria capaz de armazenar um destes smbolos. Com bits,
pode-se representar
coisas distintas;
Um cdigo uma conveno para a interpretao de conjuntos de bits. Cdigos
importantes incluem o ASCII, para a representao de caracteres, binrios sem sinal,
binrios em complemento de 2 para incluir tambm nmeros negativos, e ponto
flutuante.
As operaes booleanas NOT, AND e OR realizam as transformaes simples de bits,
mas tudo o que um computador faz atravs da composio destas operaes;
Transistores podem ser utilizados para implantar circuitos chamados portas lgicas,
que realizam as operaes booleanas. Transistores so implantados de forma
extremamente compacta em semi-condutores, e realizam as operaes booleanas
muito rapidamente.
Portas lgicas podem teoricamente realizar qualquer transformao de informao;
colocando a informao de entrada e a de sada codificadas em uma tabela da
verdade, podemos construir um circuito que realiza a transformao desejada.
Isso funciona perfeitamente para circuitos pequenos, como para a construo de um
circuito de soma completa, capaz de somar duas variveis de um bit.
O uso direto de portas lgicas para transformao de informao entretanto
limitado por razes prticas. Para a soma de dois inteiros de 32 bits, teramos uma
tabela da verdade com
. Um supercomputador que gastasse um
nanosegundo (
segundos) para processar cada entrada da tabela da verdade
demoraria 585 anos para terminar o processamento.
Por sua vez, circuitos de soma completa podem ser ligados em em cascata, em um
arranjo que permite a soma de variveis de, digamos, 32 bits cada uma.
Isto funciona para inteiros de 64 ou de 128 bits, mas dificilmente algum pensaria em
construir um circuito para calcular a soma de 20 nmeros de 32 bits cada um.
Com registradores, barramentos, unidade lgico-aritmtica e memria dispostos em
um arranjo adequado, podemos usar sinais de controle para guiar o fluxo de dados e
obter a soma de 20 ou mais nmeros de 32 bits, usando um acumulador e realizando
uma soma de cada vez.
O prximo e enorme passo a automao da emisso dos sinais de controle, com o
uso de um programa armazenado na memria, composto por instrues que so
interpretadas executadas por uma unidade central de processamento,

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Notas Finais e Prximos Passos

205

Um computador portanto um circuito que transforma informao, que entretanto


difere do circuito de soma porque a transformao realizada no fixa, mas ditada por
outra informao o programa armazenado.
Trocando o programa, trocamos a transformao realizada. O ganho em fllexibilidade
enorme, quando comparado com a construo de um circuito. Software macio;
hardware duro.
E programas podem conter loops, o que nos permite por exemplo calcular a soma de
50.000 ou mais nmeros de 32 bits faanha absolutamente impraticvel para um
circuito combinatrio, que para isso deveria ter
bits de
entrada.
A construo de um programa mesmo pequeno em linguagem de mquina uma
tarefa infernal, mas uma das principais utilidades dos computadores facilitar a
construo de programas para computadores.
Montadores ou assemblers so programas que permitem o uso de mnemnicos para a
designar instrues e posies de memria. Mesmo sendo um avano sobre a
programao direta em linguagem de mquina, a programao que se consegue com
estes sistemas ainda muito detalhada, presa a uma arquitetura especfica, sendo
propensa a erros e sem portabilidade.
Compiladores e interpretadores so tambm programas, que tm como entrada
programas escritos em uma linguagem de alto nvel, como Fortran, C ou Scilab, e que
ou bem transformam estes programas em instrues de mquina a serem executados
diretamente por um computador, ou como o caso do Scilab tm internamente
uma mquina virtual, que interpreta o programa recebido como entrada.
Linguagens de alto nvel oferecem abstraes que nos permitem escrever programas
descries de transformao de informao de uma forma muito mais prxima do
nosso raciocnio.
O Scilab, em particular, nos permite guardar valores em variveis com um nome que
podemos escolher. Esses valores podem ser numricos, caracteres, ou lgicos.
Variveis Scilab so sempre matrizes; a linguagem oferece notaes para designao
de partes de uma matriz.
Variveis, constantes, chamadas de funes, parnteses e operadores podem ser
combinados em expresses que resultam em valores Scilab, e que podem ser
empregados em comandos de atribuio para alterar valores de variveis.
A linguagem Scilab oferece tambm comandos de controle do fluxo de execuo,
como o comando condicional if-then-else, e os loops while e for.
Temos comandos de entrada e sada, como input e printf, e comandos para o
tratamento de arquivos, como mopen e mclose, mgetl, fscanfMat e
fprintfMat, que nos permitem usar armazenamento estvel para massas de dados
potencialmente grandes.
Um programa Scilab formado por um programa principal e por definies de funes
Scilab. Programas e funes Scilab so armazenados em arquivos.
Uma funo Scilab define parmetros formais de entrada e de sada. A chamada de
uma funo Scilab define parmetros reais de entrada, que so expresses Scilab, e
parmetros reais de sada, que so variveis que recebem os valores calculados pela
funo para seus parmetros formais de sada.
Funes Scilab podem conter comandos Scilab, variveis locais e chamadas de funes
incluindo possivelmente chamadas prpria funo, em um arranjo recursivo.
Ns vimos que a recursividade pode simplificar muito o desenvolvimento de
algoritmos, pois expressa de forma natural o seu comportamento.
Funes so uma importante ferramenta de modularizao. Seu uso permite o
desenvolvimento seja em momentos separados, seja por pessoas diferentes.

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Notas Finais e Prximos Passos

206

Com o domnio de uma linguagem de programao ns pudemos atacar problemas de


transformao de informao muito mais elaborados.
Problemas de transformao de informao so em princpio resolvidos por algoritmos
mtodos que prescrevem sequncias de transformaes elementares, e que so
convenientemente implantados por programas de computadores no nosso caso,
programas Scilab.
Usando a linguagem Scilab ns vimos diversos algoritmos para soluo de problemas
como leitura, processamento e escrita de dados, usando inicialmente teclado e
monitor, para pequenos volumes de dados, e depois arquivos, para grandes volumes
de dados.
Para dois problemas clssicos de transformao de informao ns vimos diversas
solues: a pesquisa por um valor em um vetor, e a ordenao de um vetor.
Ns vimos que algoritmos podem diferir e muito em sua eficincia no uso de
recursos computacionais, como tempo de execuo ou quantidade de memria.
O termo complexidade computacional de um algoritmo empregado para caracterizar
suas exigncias destes recursos como uma funo do tamanho dos dados de entrada.
Alguns problemas de transformao de informao tm limites inferiores para a
complexidade de qualquer algoritmo que o resolva. A ordenao de um vetor, por
exemplo, no melhor caso
.
Acredita-se que o limite inferior para uma classe de problemas conhecida como npcompletos, como o problema do caixeiro viajante, tem complexidade intrnseca
crescente em taxa maior que qualquer polinmio em .
Outros problemas so ainda piores. Para problemas chamados indecidveis, como o da
correspondncia de Post, no existem algoritmos com um tempo limite garantido para
qualquer entrada.

H muito o que se aprender em computao, pura ou aplicada s cincias e s engenharias., e


diversas outras disciplinas podem extender o seu conhecimento nesta rea:

Organizao de Computadores. O projeto de sistemas digitais e de computadores


uma vasta rea, que normalmente estudada em disciplinas como Sistemas Lgicos,
Organizao de Computadores, ou Arquitetura de Computadores. Metodologias para o
projeto e implantao de circuitos digitais so vistas com maior profundidade, assim
como aspectos tericos.
Clculo Numrico. Nessa disciplina so vistos, como o nome indica, algoritmos para a
soluo de problemas numricos, de grande importncia para todos os cientistas e
engenheiros. Tipicamente so vistos algoritmos para encontrar zeros (razes) de
funes (dos quais o mtodo da bisseo visto na Seo 4.4.2 um exemplo), para a
soluo de sistemas de equaes lineares, para interpolao, para soluo de
equaes diferenciais, para integrao numrica, e vrios outros. A preocupao com
erros de arredondamento e de truncamento, e com a sua propagao tratada com
muito maior profundidade.
Algoritmos e Estruturas de Dados. Esta rea trata extensamente de algoritmos para
ordenao e pesquisa (dos quais ns vimos alguns exemplos), do uso de estruturas de
dados mais flexveis que matrizes, como listas, rvores e grafos, do casamento de
padres, sempre com um tratamento bem mais rigoroso dos aspectos relacionados
complexidade.
Programao Orientada a Objetos. A programao orientada a objetos, ou POO,
oferece estruturas lingusticas para uma definio elegante de dados e de formas de
interao. A programao torna-se mais compacta e mais segura, permitindo um
intenso reaproveitamento de cdigo. Nenhum programador mais srio pode se
permitir desconhecer a POO, que foi introduzida j em 1967 com a linguagem Simula,

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Notas Finais e Prximos Passos

207

e depois explorada com Smalltalk. Estas duas linguagens ainda sobrevivem, mas o uso
de C++ e de Java hoje muito maior.
Bancos de Dados. Bancos de dados so sistemas de armazenamento que extendem
muito o conceito de arquivos. Um SGBD (Sistema de Gerncia de Banco de Dados)
como Oracle, PostGresSQL, MySQL, SQL Server, e outros, permite a recuperao de
dados por perguntas (queries, em ingls. SQL quer dizer Standard Query Language)
como me d a lista dos alunos de engenharia civil com idade entre 18 e 20 anos que
j tenham cursado Programao de Computadores ou Clculo Numrico. SGBDs
tratam tambm do controle de concorrncia, controlando o acesso simultneo a uma
mesma base por diversos usurios, e garantindo a preservao de sua integridade.
Sistemas Reativos. So sistemas que reagem a diversos estmulos de forma a, por
exemplo, controlar um alto-forno, aumentando a combusto ao perceber uma baixa
de temperatura, e diminuindo quando a temperatura do forno est alta. Sistemas
operacionais como o Windows ou o Linux so tambm exemplos de sistemas reativos,
controlando os estmulos recebidos pelos equipamentos de entrada e sada.
Engenheiros e cientistas trabalham normalmente com sistemas reativos menores,
controlando mquinas e equipamentos de laboratrios.

Para finalizar, alguns conselhos.

O Scilab adequado para o desenvolvimento de pequenos programas voltados para


cincias e engenharias. Para programas maiores, com mais de 1000 linhas, considere o
uso de outras linguagens, com C, Fortran, C++ ou Java.
Qualquer que seja a linguagem escolhida, procurer usar bibliotecas de funes
desenvolvidas por profissionais. S desenvolva o que for realmente necessrio.
Funes de boas bibliotecas tm cdigo mais robusto e mais rpido e do tratamento
adequado a erros numricos.
Experimente sempre! Enquanto voc no estiver fazendo programas para uso em
produo, errar no machuca. Dificilmente um sistema se estraga por um erro de
programao, e a experimentao essencial para o aprendizado.

***

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

ndice Remissivo

208

6 ndice Remissivo
%eps, 99
%pi, 99
.sce, 103
abertura de um arquivo, 121
ABus, 76
acumulador, 60
ADconversion, 12
lgebra Booleana, 27
algoritmo, 157
ALU, 61
ambiente Scilab, 97
AND, 27
Aritmtica matricial, 127
arquivo-programa, 103
ASCII, 23
Assembler, 65
assembly, 65
atuadores, 13
barramento, 57
Basic, 96
Binrios sem Sinal, 23
bit, 7
bloco ento, 105
bloco seno, 105
Blue Gene, 1
bps, 14
C, 96
C++, 96
cabealho da funo, 144
Carta de tempo, 55
Central Processing Unit, 64
chamadas da funo, 140
ciclo de instruo, 66
Ciclo de Micro-Instruo, 81
Circuito para sincronizao, 75
circuito principal da CPU Pipoca, 73
Cleve Moler, 96
clock, 63
Cobertura dos 1s, 38
Cobol, 96
Codificao com Deslocamento, 25
cdigo da instruo, 68
comando de atribuio, 98
Comandos Aninhados, 116
comentrios, 104
comparao de binrios sem sinal, 49
comparador de 1 bit, 49

compilador, 95, 96
Complemento de 2, 25
complexidade computacional, 158
complexidade linear, 166
condutor perfeito, 29
console do Scilab, 97
Construindo matrizes, 131
controlled buffer, 57
converso binrio-decimal, 24
converses A/D, 8
converses D/A, 8
Correo, 157
CPU, 64
data width, 56
DBus, 76
Debug, 76
Demultiplexadores, 51
descritor de arquivo, 121
desenvolvimento top-down, 151
diretrio corrente, 103
dividir para conquistar, 179
Dvorak, 13
eco, 98
supresso do eco, 99
Eficincia, 157
else, 105
endereo, 58
endfunction, 141
escopo de variveis, 142
Especificao, 157
estouro, 41
Expresses booleanas, 28
expresses lgicas, 112
eye, 132
fatorao de nmeros inteiros, 159
fechamento de um arquivo, 121
fetch, 86
flip-flop tipo D, 54
Flip-flops, 54
Fortran, 95
fprintfMat, 136
fscanfMat, 136
funo recursiva, 149
Funes, 139
function, 141
George Boole, 27
getf, 142

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

ndice Remissivo
GetOperand, 87
IBM PC, 1
IEEE 754, 26
if, 105
Indentao, 118
Informao, 4
Informao analgica, 4
informao digital, 4
input, 104
INPUT, 76
instrues, 68
instrues de desvio, 67
instrues de mquina, 65
Instruction Register, 66
int, 132
Integrao por Trapzios, 180
Internet, 3
interpretador, 96
IR, 66
isolante perfeito, 29
janela de anlise combinatria, 43
Java, 96
jsr, 79
jump to subroutine, 79
kiss principle, 168
lmpada de 7 segmentos, 46
largura de bits, 56
leg, 138
legibilidade, 117
limites fisiolgicos, 12
linspace, 131
LISP, 96
loaders, 70
Logisim, 31
mantissa, 26
MAR, 59
Mark, 2
Matlab, 96
matriz identidade, 132
matriz inversa, 129
matriz transposta, 129
Matrizes, 124
Matrizes de Strings, 135
mclose, 120
meia-soma, 39
Memrias, 15
Memrias secundrias, 15
Memrias tercirias, 16
Memory Addres Register. See MAR
meof, 120
merge, 173

209
mfprintf, 120
mfscanf, 120
mgetl, 136
micro Instruction Register, 78
micro Program Counter, 78
micro-assembler, 86
microinstrues de desvio, 79
microinstrues de sinal, 78
Micro-Programa, 86
microprogramao, 78
mIR, 78
mnemnicos, 70
modo de endereamento, 68
montador, 73
montagem, 65
mopen, 120
mPC, 78
Multiplexadores, 51
NAN, 26
NAND, 28
nomes de variveis, 98
NOR, 28
NOT, 27
ones, 131
operadores relacionais, 106
operando, 68
OR, 27
ordenao, 168
ordenao por Intercalao, 173
Ordenao por Seleo e Troca, 168
oscilador, 63
Ou Exclusivo. See XOR
OUTPUT, 76
overflow, 41
palavras, 58
parmetro da funo, 140
Parmetros formais, 141
parmetros reais, 141
partes de uma matriz, 126
Pascal, 96
PC, 66
Pesquisa Binria, 166
Pesquisa Seqencial, 165
PHP, 96
pilha, 150
Pipoca, 64
Planilha Pipoca.xls, 89
plot2d, 133
polgono, 153
Ponto Flutuante, 25
printf, 105

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

ndice Remissivo
problema de transformao de
informao, 157
processador, 7
produto elemento a elemento, 128
produto matricial, 128
Program Counter, 66
programa, 64
Programa em Execuo, 70
programa executvel, 70
Programa Executvel, 70
Programa Fonte, 70
programa principal, 140
Prolog, 96
prova formal, 157
pwd, 121
Python, 96
RAM, 15
rand, 132
rect, 153
registrador, 55
registrador circular, 63
Registradores, 15
retorno da funo, 140
return, 79
Return Address, 78
RGB, 24
RoadRunner, 1
ROM, 58
sci, 142
Scilab, 96
SciPad, 103
seleo e troca, 169
Select Sort, 168
sensores, 13
SetInEmpty, 75
SetInFull, 75
Signals, 78
Sinal e Amplitude, 24

210
Sntese de Circuitos Combinatrios, 42
size, 125
software, 65
soma de Riemann, 180
soma-completa, 40
somador de bits, 41
SomaTrs, 45
splitters, 57
Strings, 113
sub-circuito, 45
SumX, 70
supercomputador, 2
tabela da verdade, 37
teclado Dvorak, 13
testes, 157
then, 105
timer, 159
Transistores, 28
Trocar os valores de duas variveis, 170
UCP, 64
uigetfile, 120
unidade central de processamento, 64
unidade de controle, 67
unidade lgico-aritmtica, 61
vai-um, 39
Variveis, 98
variveis locais, 142
Variveis Lgicas, 112
varivel, 98
vem-um, 40
Vetores, 126
voltil, 15
volatilidade, 15
Von Neumann, 65
XOR, 33
xtitle, 138
zeros, 131

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Referncias

211

7 Referncias
Andrews, D. (n.d.). Primes R US. Retrieved from http://www.geocities.com/primes_r_us/
Burch, C. (2002). Logisim: A Graphical Tool for Designing and Simulating Logic Circuits.
Retrieved March 2009, from http://ozark.hendrix.edu/~burch/logisim/
Dijkstra, E. W. (1972). Chapter I Notes on Structured Programming. In E. W. O. J. Dahl,
Structured Programming. Eds. ACM Classic Books Series. Academic Press Ltd., London, UK, 182.
Flickr. (n.d.). Retrieved Fevereiro 2010, from
http://farm4.static.flickr.com/3444/3348244651_fef16ef641.jpg
Garey, M. R., & Johnson, D. S. (1979). Computers and Intractability: A Guide to the Theory of
NP-Completeness. New York, USA: W. H. Freeman & Co.
Hollasch, S. (2005). IEEE Standard 754 Floating Point Numbers. Retrieved August 25, 2009,
from http://steve.hollasch.net/cgindex/coding/ieeefloat.html
HotHardware.com. (n.d.). Intel Core 2 Extreme QX9770 Performance Preview. Retrieved
Fevereiro 2010, from
http://hothardware.com/articles/Intel_Core_2_Extreme_QX9770_Performance_Preview/
I.Ziller, J. B. (1954). Preliminary Report: Specifications for the IBM Mathematical FORmula
TRANslating System, FORTRAN. International Business Machines, Applied Science Division.
IBM. (n.d.). IBM Archives - Personal Computer. Retrieved 2009, from http://www03.ibm.com/ibm/history/exhibits/pc/pc_1.html
Lohninger, H. (2006). (Vienna University of Technology) Retrieved from
http://www.vias.org/simulations/simusoft_adconversion.html
Lyon, B. (2005). The Opte Project. Retrieved August 2009, from http://opte.org/
Mathworks. (n.d.). Retrieved Fevereiro 2010, from http://www.mathworks.com/
McJones, P. (n.d.). History of FORTRAN and FORTRAN II. (Computer History Museum) Retrieved
April 2009, from Software Preservation Group:
http://www.softwarepreservation.org/projects/FORTRAN/
McKeeman, B. (n.d.). MATLAB 101 - A talk for the MIT Computer Science Department.
Retrieved Fevereiro 2010, from
http://www.cs.dartmouth.edu/~mckeeman/references/matlab101/matlab101.html
Morris, R. J. (2003). The Evolution of Storage Systems. IBM Systems Journal , 42 (2), 205-217.
Neumann, J. v. (1945). Michael D. Godfrey home page. Retrieved Maro 2010, from
http://qss.stanford.edu/~godfrey/vonNeumann/vnedvac.pdf
O'Reilly Media. (n.d.). Language Poster. Retrieved April 2009, from History of Programming
Languages: http://oreilly.com/news/languageposter_0504.html
Scilab Consortium. (n.d.). Scilab Home Page. Retrieved from http://www.scilab.org/
StatLib. (1989). StatLib - Datasets Archive. (Department of Statistics, Carnegie Mellon
University) Retrieved March 2009, from http://lib.stat.cmu.edu/datasets/
Top500. (n.d.). Top 500 supercomputers. Retrieved from http://www.top500.org

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3

Referncias

212

Wolffdata. (n.d.). Wolffdata. Retrieved 2008, from ScilabStarter:


http://www.wolffdata.se/scilab/ScilabStarter.pdf

Introduo Organizao e Programao de Computadores

IOPC 2010_2-3