Apostila - Introdução A Computação PDF

INTRODUÇÃO À COMPUTAÇÃO
Maceió, 2009
SUMÁRIO
LISTA DE FIGURAS ................................................................................................. v

LISTA DE TABELAS ................................................................................................ vi
1 Introdução...........................................................................................................7
1.1 Motivação .........................................................................................................7
1.2 Histórico e Desenvolvimento dos Computadores...................................................8
1.3 Sistemas de Computação ................................................................................. 12
1.3.1 Arquitetura................................................................................................... 13
1.3.1.1 Unidade de Entrada ................................................................................... 13
1.3.1.2 Memória.................................................................................................... 13
1.3.1.3 Unidade Central de Processamento (CPU) .................................................... 14
1.3.1.3.1 Unidade Lógica e Aritmética ..................................................................... 15
1.3.1.3.2 Unidade de Controle................................................................................ 15
1.3.1.4 Unidade de Saída....................................................................................... 15
2 Noções de Lógica e Algoritmos ............................................................................ 15
2.1 Noções de Lógica ............................................................................................ 15
2.2 Algoritmos ...................................................................................................... 16
2.2.1 Conceituação................................................................................................ 16
2.2.2 Refinamentos Sucessivos............................................................................... 18
2.2.3 Programa Computacional .............................................................................. 19
2.3 Linguagens de Programação............................................................................. 19
2.4 Introdução ao MATLAB .................................................................................... 22
2.4.1 Execução do MATLAB.................................................................................... 23
2.4.2 Alguns Comandos Básicos ............................................................................. 23
3 Tópicos Preliminares........................................................................................... 27
3.1 Tipos Primitivos............................................................................................... 28
3.2 Constantes...................................................................................................... 28
3.2.1 Constante Numérica...................................................................................... 28
3.2.2 Constante Lógica .......................................................................................... 28
3.2.3 Constante Literal .......................................................................................... 28
3.3 Variáveis......................................................................................................... 29
3.4 Expressões Aritméticas .................................................................................... 30
3.4.1 Operadores Aritméticos ................................................................................. 31
3.4.2 Prioridades................................................................................................... 32
3.5 Expressões Lógicas.......................................................................................... 33
3.5.1 Operadores Relacionais ................................................................................. 33
3.5.2 Operadores Lógicos ...................................................................................... 34
3.5.2 Prioridades................................................................................................... 36
3.6 Expressões Literais .......................................................................................... 37
3.7 Comando de Atribuição .................................................................................... 40
3.8 Comandos de Entrada e Saída .......................................................................... 40
3.9 Blocos ............................................................................................................ 44
4 Estruturas de Controle ........................................................................................ 44
4.1 Estruturas Seqüenciais ..................................................................................... 44
4.2 Estruturas de Controle de Fluxo ........................................................................ 46
4.2.1 Estruturas de Seleção (Condicional) ............................................................... 46
4.2.1.1 Seleção Simples......................................................................................... 46
4.2.1.2 Seleção Composta...................................................................................... 47
4.2.1.2 Seleção Encadeada .................................................................................... 48
4.2.1.4 Seleção de Múltipla Escolha ........................................................................ 49
4.2.1.5 Exercícios .................................................................................................. 49
4.3 Estruturas de Repetição ................................................................................... 51
4.3.1 Estruturas de Repetição Definidas .................................................................. 51
4.3.2 Estruturas de Repetição Indefinidas ............................................................... 54
4.3.2.1 Exercícios .................................................................................................. 55
5 Estruturas de Dados ........................................................................................... 57
5.1 Introdução...................................................................................................... 57
5.2 Variáveis Compostas Homogêneas .................................................................... 57
5.2.1 Variáveis Compostas Homogêneas Unidimensionais......................................... 58
5.2.2 Variáveis Compostas Homogêneas Multidimensionais...................................... 62
5.3 Variáveis Compostas Heterogêneas................................................................... 65
6 Modularização.................................................................................................... 68
6.1 Introdução...................................................................................................... 68
6.2 Módulos (Funções) .......................................................................................... 69
6.3 Argumentos (Parâmetros) de Funções............................................................... 72
6.4 Valores de Retorno de Funções ........................................................................ 74
Referências Bibliográficas ...................................................................................... 80
v
LISTA DE FIGURAS
Figura 1 – Stonehenge ............................................................................ 8

Figura 2 – Exemplos de ábacos ................................................................ 9
Figura 3 – Régua de cálculo ....................................................................10
Figura 4 – Arquitetura básica de um computador......................................13
Figura 5 – Compilador ............................................................................20
vi
LISTA DE TABELAS
Tabela 1 – Linguagens de programação ...................................................20

Tabela 2 – Prioridades das operações ......................................................37
7
INTRODUÇÃO À COMPUTAÇÃO
1 Introdução
Este primeiro capítulo tem por objetivo motivar o leitor para o estudo do tema
“Introdução à Ciência da Computação”, apresentar um breve histórico a respeito do
desenvolvimento dos computadores, a forma como esses são organizados e a
explicação de alguns termos técnicos.
1.1 Motivação
Pode-se dizer que o estudo da introdução à computação é o primeiro passo em
direção ao conhecimento do mundo da tecnologia e funcionamento dos computadores.
O uso de computadores no dia-a-dia tem sido cada vez mais freqüente. Em todas
as áreas de estudo, pesquisa e trabalho eles são essenciais. Veja um exemplo simples
que serve para ilustrar esta afirmação.
Considere que se deseja fazer um levantamento para avaliar qual o melhor aluno
do ano de 2005 em uma determinada universidade. Naturalmente, poderíamos pegar
as cadernetas escolares de todos os alunos, calcular a média de suas notas e verificar
qual aluno obteve a maior média. Isso representa um trabalho muito laborioso, pois a
quantidade de informações (dados) a serem levantados é extremamente grande.
Mas e se tivermos um computador? Como ele pode ser útil para resolver o nosso
problema? Simples. É necessário apenas garantir que todos os dados dos alunos
estejam armazenados em um computador e que se possa usar um programa
computacional para fazer os cálculos desejados. Em questão de segundos poderíamos
ter a resposta desejada.
Mas qual programa usar? Existem duas alternativas: uma é comprar um
programa comercial (e existem vários) que possa ser utilizado para resolver o
problema. A outra é desenvolvermos o nosso próprio programa.
O presente curso tem com objetivo fornecer uma base teórica e prática para
permitir o aprendizado, capacitando o leitor a desenvolver programas computacionais
para resolver os mais diversos problemas do nosso cotidiano, principalmente aqueles
relacionados à Engenharia.
8
1.2 Histórico e Desenvolvimento dos Computadores

O objetivo deste item é dissertar a respeito da descoberta do computador e a
sua evolução ao longo do tempo.
Antes de apresentar o que é e como surgiu o computador, define-se aqui o
termo “informática”, criado na França por volta de 1962.
information automatique = informação automática
Ou seja, informática é a ciência que estuda o tratamento automático e racional

da informação com uso de equipamentos e procedimentos da área de processamento
de dados. Trata do estudo e desenvolvimento de máquinas e métodos para processar
informações.
As principais funções da informática são:
• Desenvolvimento de novas máquinas;
• Desenvolvimento de novos métodos de trabalho;
• Construção de aplicações automáticas;
• Melhoria dos métodos e aplicações existentes.
Desde que o homem começou a processar dados, ele tentou construir máquinas
que pudessem ajudá-lo em seu trabalho. O computador eletrônico é o resultado dessas
tentativas que vêm sendo realizadas através dos tempos. Certamente, o computador é
um dos principais produtos da ciência do século XX.
Para alguns pesquisadores, Stonehenge é o primeiro computador feito pelo
homem. Trata-se de um monumento paleolítico constituído de blocos de pedra de 3 a 6
metros de altura, construído entre 2.600 a.C. a 1.700 a.C., na planície de Salisbury, na
Grã-Bretanha. Em 1960 um astrônomo americano (utilizando computador!) mostrou
que se tratava de um meio capaz de prever eclipses lunares.
Figura 1 – Stonehenge
9
Porém, a maioria dos estudiosos considera o ábaco o primeiro hardware da

história da computação. Registros históricos de cerca de 2.000 a.C. comprovam que o
ábaco era utilizado no oriente. Consiste de uma tábua com hastes que trespassam
contas com formato lenticular com seção transversal hexagonal.
Ábaco chinês
Ábaco russo
Ábaco japonês
Figura 2 – Exemplos de ábacos
O ábaco japonês é chamado de Soroban e foi trazido da china em 1622. O

Soroban começou como um instrumento simples destinado a registrar valores e realizar
operações de soma e subtração. Posteriormente, foram desenvolvidas técnicas de
multiplicação e divisão; atualmente, já são conhecidas técnicas para extração de raízes
(quadrada e cúbica), operação com horas, minutos e segundos e conversão de pesos e
medidas. É possível trabalhar com números inteiros, decimais e negativos.
O ábaco chegou ao Brasil em 1908 trazido por imigrantes. Sua versão moderna,
introduzida em 1953, teve sua técnica de utilização difundida pelo Prof. Fukutaro Kato,
em 1956.
Em 1621, o matemático inglês William Outgred inventou a régua de cálculo,
considerada um dos primeiros dispositivos analógicos de computação.
10
Figura 3 – Régua de cálculo
Em 1642/1647, o francês Blaise Pascal conseguiu somar e subtrair utilizando sua

máquina, conhecida como Pascalina, por meio de engrenagens mecânicas.
Em 1801, o matemático francês Joseph Marie Jacquard consegue armazenar
informações em placas perfuradas, para controle de máquinas de tecelagem. A
invenção gerou grande temor de desemprego.
Em 1820, uma máquina de calcular criada pelo francês Charles Thomas de
Colmar vende mais de 1.500 unidades. As Arithmometers, como eram chamadas, são
consideradas o primeiro sucesso de vendas no setor.
Em 1822, Ada Lovelace, filha do famoso poeta Lord Byron, é contratada pelo
inglês Charles Babbage para programar sua então criada máquina diferencial. Ada é
considerada a primeira programadora do mundo.
Em 1854, George Boole estabelece os princípios binários que seriam utilizados
posteriormente como base para o estudo de lógica matemática.
Em 1880, Hermann Hollerith, constrói uma máquina de tabulação, utilizada no
senso norte-americano.
Em 1896, Hermann Hollerith funda a Tabulating Machine Company.
Em 1911, Hollerith associa-se a outras empresas e a Tabulating Machine
Company passa a ser dirigida por Tomas Watson.
Em 1924 nasce a IBM (International Business Machine Corporation), resultado da
associação de Hollerith com Watson.
Em 1931 o primeiro computador analógico é construído pelo MIT (Massachusetts
Institute of Technology).
Em 1937, Howard Haiken, professor de matemática de Harvard, convence Tomas
Watson da IBM a fabricar o primeiro computador eletromecânico, o MARK I.
11
Em 1939 surgiu o primeiro computador eletrônico digital, o ABC (Atanasoff Berry

Computer), que foi apresentado pelo professor de matemática John Atanasoff.
Em 1943, a Inglaterra constrói, com o auxílio de Alan Turing, dez computadores
Colossus I. Esse equipamento eletrônico digital, a válvulas, foi utilizado para decifrar
códigos militares dos alemães.
Em 1946 é apresentado o primeiro grande computador eletrônico da época, o
ENIAC (Electronic Numeric Integrator Analyser and Calculator). O ENIAC ocupava quase
200m2, pesava 30 toneladas e conseguia resolver 5.000 adições por segundo.
Em 1950, John von Neumann, Arthur Burks e Hermann Goldstine desenvolvem
conceitos de programação e operações por números binários utilizados até hoje.
Em 1951, o UNIVAC I, primeiro computador a utilizar os conceitos de von
Neumann, é produzido em escala comercial. Tinha 20 m2 e pesava 5 toneladas.
Em 1953 é lançado o computador IBM 701.
Em 1954 é lançado o IBM 650, maior sucesso de vendas da década.
O ano de 1959 marca o fim dos computadores de primeira geração, baseados
em válvulas. Assim, a evolução dos computadores pode ser dividida nas seguintes
etapas:
¾ Computadores da 1a Geração:
y Utilização de circuitos eletromecânicos e válvulas.
y Utilização de transistores (controlam a passagem de corrente)
à Redução do tamanho e da potência consumida;
à Dispositivos mais robustos e confiáveis.
y Circuitos integrados
à Integração de vários transistores em uma única embalagem com a dimensão
aproximada de um transistor;
à Maior potência de cálculo;
à Mais rápidos;
à Mais confiáveis;
à Menores fisicamente.
y Circuitos integrados em altíssima escala
à Integração de milhares de transistores em uma única pastilha.
Além da evolução acima, pode-se destacar a evolução das telecomunicações

usando a mesma tecnologia. Isso viabilizou o uso de recursos de telecomunicações
12
(internet, por exemplo) aplicados à computação, possibilitando o uso à distância de um

computador por um ou vários usuários.
1.3 Sistemas de Computação

Um sistema de computação é formado por usuários, software e hardware; cada
um desses componentes será definido posteriormente.
O objetivo de um sistema de computação é realizar o processamento dos dados,
que é a execução de processos sobre o dado original para transformá-lo em uma
informação.
Software ou programa é a parte lógica que dota o equipamento físico com a
capacidade de realizar algum trabalho. O programa nada mais é que uma seqüência de
instruções escritas em uma linguagem de programação, informando ao hardware o que
fazer em que ordem.
Hardware é a parte física de um sistema de computação, ou seja, todos os
elementos materiais que o constitui (circuitos eletrônicos, dispositivos mecânicos,
elétricos e magnéticos).
Existem dois tipos de computadores: os analógicos e os digitais. Um termômetro
é um exemplo de funcionamento por analogia, pois a dilatação de mercúrio é análoga à
mudança de temperatura.
O princípio da analogia também é utilizado em uma régua de cálculo (figura 3),
que pode ser considerada como um computador analógico, onde as operações de
multiplicação e divisão são executadas simplesmente somando-se ou subtraindo-se a
distância medida na régua externa àquela marcada na régua interna deslizante.
Um dos primeiros computadores analógicos de grande porte foi construído para
prever a altura das marés nos portos ingleses.
Os computadores analógicos de hoje são capazes, por exemplo, de simular as
forças que atuam numa represa ou as forças que atuam nas asas de um avião a partir
da voltagem elétrica.
Resumindo, os computadores analógicos são caracterizados por lidarem com
grandezas contínuas. Neles, as variáveis do problema são representadas por tensões,
que são quantidades físicas contínuas.
Ao contrário dos computadores analógicos, que trabalham com grandezas físicas,
os computadores digitais são capazes de somar, subtrair, multiplicar, dividir e comparar
13
através de pulsações elétricas que, em última análise, representam os dígitos 0

(ausência de corrente) e 1 (presença de corrente).
Os computadores digitais serão o foco deste nosso curso.
1.3.1 Arquitetura
Esta seção trata da estrutura de um computador digital.
O esquema de um computador digital pode ser representado pela figura 4.
Memória
Unidade de Unidade de Unidade de

Entrada Controle Saída
Unidade Lógica
e Aritmética
CPU
Figura 4 – Arquitetura básica de um computador
A seguir, são descritos cada componente do computador digital.
1.3.1.1 Unidade de Entrada

Esta unidade traduz informação de uma grande variedade de dispositivos em um
código que a unidade central de processamento (CPU) é capaz de entender. Em outras
palavras, ela é capaz de traduzir números, letras e imagens em pulsos elétricos que são
compreensíveis ao computador. Alguns exemplos de unidades de entrada são: teclado,
unidades de discos (disquetes e cds, por exemplo), scanners, mouse, leitores ópticos,
etc. As unidades de entrada também são conhecidas como periféricos.
1.3.1.2 Memória
É o local físico capaz de armazenar os dados e também os programas que irão
manipulá-los. Também conhecida como memória RAM (Randon Access Memory).
14
Geralmente, a memória de alta velocidade é utilizada para armazenar

temporariamente dados e programas que estão sendo processados, já que qualquer
programa, para ser executado, tem que estar nessa memória. Além disso, as unidades
de controle e lógica e aritmética se comunicam com cada um de seus bytes. Essa
memória costuma ser chamada de memória principal.
Ao menor item de informação binária dá-se o nome de bit. A palavra bit é uma
contração de binary digit (dígito binário) significando um dígito que pode assumir um
dos dois valores de estados diferentes 0 ou 1, tal qual um dígito decimal pode assumir
um dos dez valores 0, 1, 2, ..., 9.
Os bits são agrupados de modo a possibilitar ao usuário representar os dados e
programas que deseje. Denomina-se byte a um conjunto de bits. Cada byte armazena o
equivalente a um caractere. O número de bits que formam um byte não é fixo e
dependem exclusivamente da máquina considerada. O mais usual é encontrar os bytes
constituídos de 8 bits.
A memória do computador é constituída por um conjunto de bits, sendo que o
byte recebe um endereço a fim de que os programas possam fazer referência aos seus
dados.
A capacidade de um computador normalmente é medida pelo tamanho da sua
memória.
Cada 1024 bytes representam 1 kbyte (quilobyte). Cada 1024 kbytes
representam 1 Mbyte (megabyte). 1024 Mbytes representam 1 Gbyte (gigabyte).
1.3.1.3 Unidade Central de Processamento (CPU)

A Unidade Central de Processamento de um computador, devido a sua
complexidade, é normalmente dividida em duas partes: unidade lógica e aritmética, e
unidade de controle.
Devido ao desenvolvimento da microeletrônica é possível construir toda uma CPU
em uma única pastilha de Silício. Essa pastilha, ou chip, denomina-se microprocessador.
Como exemplo, podemos citar INTEL PENTIUM IV, MOTOROLA 6800, INTEL CELERON,
etc.
Os microprocessadores são classificados pelo comprimento, em bits, da unidade
de informação que são capazes de processar de uma só vez. Atualmente, os
microprocessadores mais usuais são os de 32 bits.
15
Resumindo, o microprocessador é a unidade central de processamento (CPU) de

um microcomputador.
A seguir, são descritas as unidades que constituem a CPU.
1.3.1.3.1 Unidade Lógica e Aritmética

Nesta unidade são realizados todos os cálculos aritméticos (adição, subtração,
multiplicação e divisão) e qualquer manipulação de dados (sejam eles numéricos ou
não).
1.3.1.3.2 Unidade de Controle

É a unidade responsável pelo “tráfego” de dados. Ela obtém dados armazenados
na memória e interpreta-os. Controla a transferência de dados da memória para a
unidade lógica e aritmética, da unidade de entrada para a memória e da memória para
a unidade de saída.
1.3.1.4 Unidade de Saída

Os dados processados são convertidos, por esta unidade, de impulsos elétricos
em palavras ou números que podem ser disponibilizados ao usuário final. Exemplos
dessas unidades são o vídeo (monitor), impressoras, unidades de disco (disquetes e
cds, por exemplo), etc. Assim como as unidades de entrada, as unidades de saída
também são conhecidas como periféricos.
2 Noções de Lógica e Algoritmos
Para compreender melhor o processo de criação de programas computacionais, é

necessário entender os conceitos de lógica de programação e algoritmos, que serão
descritos nas seções seguintes.
2.1 Noções de Lógica

Lógica de programação significa o uso correto das leis do pensamento e de
processos de raciocínio para a produção de soluções logicamente válidas e coerentes,
que resolvam com qualidade os problemas que se deseja programar. Ou seja, é a
técnica de encadear pensamentos para atingir determinado objetivo.
16
A Lógica de programação pode ser representada em qualquer uma das inúmeras

linguagens de programação, com a utilização dos algoritmos.
O aprendizado dessa técnica é necessário para quem deseja trabalhar com o
desenvolvimento de sistemas e programas computacionais.
2.2 Algoritmos
2.2.1 Conceituação
Algoritmo é uma seqüência ordenada e sem ambigüidades de passos finitos que
visam atingir um objetivo bem definido e, conseqüentemente, levam à solução de um
problema.
Algoritmo não é a solução do problema. Algoritmo é o conjunto de passos ou
ações (caminhos) que levam à solução de um dado problema.
Em um algoritmo é importante salientar que:
9 Deve descrever exatamente as instruções que devem ser executadas e em que
seqüência.
9 A ordem dos passos deve ser precisamente determinada.
9 Eficiente: resolve o problema com um mínimo de recursos.
9 Eficaz: consegue resolver o problema em qualquer situação. Todas as situações
de exceção que possam alterar o comportamento do algoritmo devem ser
especificadas e tratadas.
Existem várias formas de representar os algoritmos, como, por exemplo:

descrição narrativa, fluxograma ou diagrama de blocos, pseudocódigos etc.
O exemplo abaixo ilustra o uso de um algoritmo do tipo descrição narrativa para
resolver um dado problema.
Exemplo 1:
Problema: Deseja-se falar com alguém através de um telefone público. Como

proceder?
Solução: Seguir os passos descritos no telefone (algoritmo)

17
1 – Retirar o telefone do gancho;

2 – Esperar o sinal;
3 – Colocar o cartão;
4 – Discar o número;
5 – Falar ao telefone;
6 – Colocar o telefone no gancho;
7 – Retirar o cartão.
O algoritmo é exatamente esta seqüência de passos que foi utilizado para

resolver o problema proposto. É como se fosse ensinar uma máquina a fazer alguma
tarefa específica.
Normalmente, existem vários caminhos que levam à solução de um problema.
Podemos concluir, então, que existem diversos algoritmos que podem ser utilizados
para encontrar uma solução.
O aprendizado de algoritmos não é uma tarefa muito fácil. Só conseguimos
utilizá-lo racionalmente através de muitos exercícios práticos.
Exercício 1: Algoritmo para o final de semana
1 – Ver a previsão do tempo;

2 – Se fizer sol
ir à praia;
Senão
Estudar;
3 – Almoçar;
4 – Ver televisão;
5 – Dormir.
Exercício 2: Algoritmo para fazer uma prova
1 – Ler a prova;
18
2 – Pegar a caneta;
3 – Enquanto houver questão em branco e enquanto o tempo não terminou
faça
Se souber fazer a questão

Resolvê-la;
Senão
Pular para a próxima;
4 – Entregar a prova.
2.2.2 Refinamentos Sucessivos

Um algoritmo é considerado completo se os seus comandos forem do
entendimento do seu destinatário.
Num algoritmo, um comando que não for do entendimento do destinatário terá
de ser desdobrado em novos comandos, que constituirão um refinamento do comando
inicial. Por exemplo, o algoritmo para trocar uma lâmpada queimada poderia ser:
1 – Remova a lâmpada queimada.

2 – Coloque uma lâmpada nova.
Detalhando ou refinando os passos:
1.1 – Coloque uma escada embaixo da lâmpada queimada.

1.2 – Suba na escada até alcançar a lâmpada queimada.
1.3 – Gire a lâmpada queimada no sentido anti-horário até que ela se solte.
2.1 – Escolha uma lâmpada nova de mesma potência da queimada.
2.2 – Posicione a lâmpada nova no soquete.
2.3 – Gire a lâmpada no sentido horário até que ela se firme.
2.4 – Desça da escada.
2.5 – Guarde a escada.
19
Se um comando de um refinamento for um tanto vago, ele poderá, por sua vez,
ser desdobrado em novos comandos, produzindo-se o refinamento de um refinamento,
e assim sucessivamente.
2.2.3 Programa Computacional

É um algoritmo escrito em uma linguagem computacional (C, Fortran, Pascal,
MATLAB etc). É a tradução do algoritmo para uma linguagem que será interpretada
pelo computador. O mais importante de um programa computacional é a sua lógica, o
raciocínio utilizado para resolver o problema (ou seja, o algoritmo).
2.3 Linguagens de Programação

Para armazenar um algoritmo na memória do computador e para que ele possa,
em seguida, comandar as operações a serem executadas, é necessário que ele seja
programado, ou seja, transcrito para uma linguagem que o computador possa
“entender” direta ou indiretamente.
Os computadores só podem executar diretamente os algoritmos expressos em
linguagem de máquina, que é um conjunto de instruções capazes de ativar diretamente
os dispositivos eletrônicos do computador.
Essa linguagem tem vários inconvenientes para os humanos:
• Diferente para cada tipo de computador, pois depende da sua arquitetura;
• Extremamente rudimentar;
• Expressa em forma numérica, tornando-se pouco expressiva;
• Manipulação dos dados na memória.
Para suprir esses problemas, foram desenvolvidas linguagens em que a

programação é feita através de uma notação matemática e de algumas palavras
reservadas. As linguagens de programação são bem mais simples e podem ser
facilmente entendidas e utilizadas pelos usuários do computador.
Os programas escritos nessas linguagens são traduzidos para a linguagem de
máquina através de um programa especial chamado Compilador.
20
Linguagem de Linguagem de
Programação Máquina
Compilador
Figura 5 – Compilador
Como exemplo de linguagens de programação, podemos citar o Fortran, C, C++,

Pascal, Cobol, MATLAB etc.
O MATLAB, cujos detalhes serão descritos nas seções seguintes, tem uma
característica bem particular. Ele não só incorpora as características de uma linguagem
de programação, mas também do compilador. Isso será visto com mais detalhes na
seqüência deste curso.
A tabela 1 apresenta uma genealogia de várias linguagens de programação.
Observa-se que o ano associado a cada linguagem pode significar os anos do projeto
da linguagem, da sua implementação ou da sua primeira descrição publicada.
Tabela 1 – Linguagens de programação
Linguagem
Linguagem Ano Criador Objetivo
originária
FORTRAN 1954-57 J. Backus Computação numérica
ALGOL 60 1958-60 Comitê FORTRAN Computação numérica
Processamento
COBOL 1959-60 Comitê
de dados de negócios
LISP 1956-62 J. McCarthy Computação simbólica
J. Kemeny
BASIC 1964 FORTRAN Educacional
and T. Kurtz
SIMULA 67 1967 O. -J. Dahl ALGOL 60 Simulação
Algol 68 1963-68 Comitê ALGOL 60 Objetivos gerais
Pascal 1971 N. Wirth ALGOL 60 Educacional
PROLOG 1972 A. Colmerauer Inteligência artificial
C 1972 D. Ritchie Algol 68 Programação de sistemas
Pascal atual 1975 P. Brinch Hansen Pascal Programação concorrente
Pascal Objetivos gerais
Ada 1979 J. Ichbiah
SIMULA 67 Sistemas embutidos
SIMULA 67
Smalltalk 1971-80 A. Kay Computação pessoal
LISP
C
C++ 1984 B. Stroutrup Objetivos gerais
SIMULA 67
21
Tabela 1 – Linguagens de programação
Linguagem
Linguagem Ano Criador Objetivo
originária
Eiffel 1988 B. Meyer SIMULA 67 Objetivos gerais
Java 1995 SUN Microsystems C++ Computação em rede
Algumas observações podem ser feitas a respeito das linguagens apresentadas

na tabela 1.
As linguagens FORTRAN e ALGOL 60 foram desenvolvidas como ferramentas
para resolver problemas científicos numéricos (sistemas de equações, por exemplo), ou
seja, problemas envolvendo computação complexa e dados relativamente simples.
COBOL foi desenvolvido como uma ferramenta para resolver problemas de
processamento de dados de negócios, ou seja, problemas envolvendo computação
simples e grandes quantidades de dados estruturados, como por exemplo, uma
aplicação de folha de pagamento. A exceção do ALGOL 60 – que originou outras
linguagens, como Pascal, mas não sobreviveu aos dias atuais –, FORTRAN ainda está
entre as linguagens de programação mais utilizadas. As razões para este sucesso tão
longo podem ser: a relutância dos usuários em mudar para linguagens mais novas, por
causa de necessidade de compatibilidade com aplicações existentes ou simplesmente
por medo da mudança; e o fato de que essa linguagem tem evoluído: FORTRAN 66,
FORTRAN 77 e FORTRAN 90.
SIMULA 67, um sucessor da linguagem ALGOL 60, introduziu o conceito de
classe, um esquema de modularização que pode agrupar um conjunto de rotinas
relacionadas e estruturas de dados. Classes podem ser organizadas como hierarquias
de especialização crescente. O conceito de classe influenciou a maioria das linguagens
desenvolvidas após o SIMULA 67, tais como: C++, Smalltalk, Java e Eiffel.
A linguagem de programação Pascal também obteve muito sucesso. Apesar de
ter sido concebida inicialmente como uma ferramenta para o ensino de programação
estruturada, houve uma rápida expansão de interesse em Pascal com o advento de
computadores pessoais de baixo custo. A principal vantagem da linguagem é sua
simplicidade.
Também por razões de simplicidade, Basic é outra linguagem que foi
desenvolvida no meio dos anos 60 e que foi muito popular. Melhorias recentes, como
22
Visual Basic, promoveram facilidades de alto nível para o rápido desenvolvimento de

aplicações interativas baseadas no ambiente windows.
A linguagem de programação C, desenvolvida no início dos anos 70, é hoje uma
das linguagens mais utilizadas por causa de sua potencialidade e eficiência para
programação de sistemas.
A versão atual de Ada apresentada em 1995, Ada 95, incorpora várias melhorias
sobre a versão original, em particular, suporte para programação orientada a objetos.
As origens da programação orientada a objetos remontam à linguagem de
programação Simula 67. Porém, este paradigma só ficou popular por causa do sucesso
do Smalltalk, no final dos anos 70, e do C++. A linguagem de programação C++ teve
êxito na implantação de características de orientação a objetos em uma linguagem de
sucesso e amplamente acessível como C. Isto permitiu que muitos programadores
migrassem de um paradigma de programação convencional para outro considerado
melhor. Eiffel é outra linguagem orientada a objetos.
C++ parece estar ganhando aceitabilidade crescente como uma linguagem de
programação para fins diversos, primeiro porque suporta programação orientada a
objetos e segundo porque não requer o abandono de métodos convencionais.
Uma direção importante para novos desenvolvimentos está na área de
computação em rede. Java, derivado de C++ suportando mobilidade de código na
Internet, pode ser visto como o ponto inicial de uma nova geração de linguagens de
programação.
Por fim, é importante dizer que a escolha da melhor linguagem depende da
aplicação. É preciso aprender a lidar com uma variedade de linguagens e ser capaz de
migrar de linguagem a linguagem quando necessário, ou seja, quando a aplicação
mudar. As linguagens evoluem e novas aparecem quando novas necessidades de
aplicação emergem.
2.4 Introdução ao MATLAB

O MATLAB é um programa que incorpora duas características básicas essenciais.
A primeira refere-se ao fato dele possuir uma “linguagem de programação” que pode
ser usada para desenvolver programas computacionais. A segunda está relacionada
com o fato de ser um programa de computação numérica, podendo ser usado para
23
resolver não só operações matemáticas complexas, mas também auxiliar na solução de

problemas das mais diversas áreas, incluindo a Engenharia.
Este curso dá ênfase ao uso do MATLAB como “linguagem de programação”,
permitindo a construção de programas computacionais para a solução dos mais
diversos tipos de problemas.
Na realidade, será visto uma noção geral e superficial do MATLAB como um todo.
Àqueles que têm um interesse maior no seu aprendizado, recomenda-se um estudo
mais aprofundado das referências indicadas.
2.4.1 Execução do MATLAB

O MATLAB possui basicamente duas áreas de trabalho: a janela principal, onde é
realizado o gerenciamento do MATLAB (e de suas tarefas); e a janela de comandos que
é o principal local de interação com o programa.
2.4.2 Alguns Comandos Básicos

Comando de Espera
• >>
Finalização dos comandos
• <Enter>
Exemplo 01:
>> 5 * 3 + 4
ans = 19
Nota-se que o MATLAB funciona como calculadora (executa matemática

elementar).
24
Exemplo 02:
>> a = 5
>> b = 3
>> c = 4
>> a * b + c
ans = 19
Neste exemplo, = é o comando de atribuição, e a, b, e c são variáveis. Esses

detalhes serão vistos na próxima seção.
Uso do ponto e virgula
Exemplo 03: uso do ponto e vírgula
>> a = 5;
>> b = 3;
>> c = 4;
>> a*b + c
ans = 19
Limpando a tela
Exemplo 04: limpando a tela
>> clc
Esse comando não remove as variáveis criadas. Elas continuam existindo.
Verificação de variáveis
25
Exemplo 05: como verificar quais variáveis estão sendo

usadas
>> who
ans b
a c
Visualização de variáveis
Exemplo 06: como visualizar os valores armazenados em cada

variável
>> a
a=5
Outros comandos
Exemplo 07: outros comandos
Usar teclas <K ou L>
Comentários
• Usar o caractere %
Exemplo 08:
>> % a variável b tem valor inicial = 5

>> b = 5;
Configuração de Janelas
• Menu View
26
o Passo 1: Selecionar Desktop Layout / Default;

o Passo 2: Desselecionar Command History.
• Comando Clear
o Apagar uma variável específica;
o Apagar todas as variáveis.
Exemplo 9:
>> clear b
Erro
>> b
>> clear
Comandos Save/Open
• Salvar e ler os dados e informações digitadas.
Arquivos M de Comandos
São arquivos usados em problemas mais complexos. São arquivos de texto

simples. O Seu processamento é feito através da sua execução pelo MATLAB usando,
para isso, o Menu File/New (M-File).
Exemplo 10: arquivo M
% arquivo M – exemplo
a = 4;
b = 5;
c = 3;
a*b+c
Observações importantes:
• Salvar no diretório de trabalho (na janela de comandos do MATLAB);

27
• Executar: >> <nome do arquivo> ou RUN.
Funções de Entrada e Saída
Comandos usados para fornecer dados ao programa computacional ou imprimir

resultados na tela do computador.
• input: Entrada de dados pelo teclado
Exemplo 11:
>> a = input(‘Escreva o numero a: ’);

>> b = input(‘Entre com um nome: ’,
‘s’);
• disp: Imprime na tela um valor
Exemplo 12: arquivo M
RUN
a = input(‘a: ’);
b = input(‘b: ’);
c = input(‘c: ’);
d = a*b + c;
disp(d);
3 Tópicos Preliminares
Esta seção descreve os principais tópicos preliminares usados na elaboração de

programas computacionais. Esses tópicos serão apresentados e inseridos dentro do
contexto da linguagem de programação MATLAB, adotada neste curso. Deve-se dedicar
atenção especial a este capítulo, pois ele contém os fundamentos necessários para a
compreensão dos seguintes.
28
3.1 Tipos Primitivos

São os tipos básicos usados para armazenar as informações relacionadas aos
dados utilizados pelo programa computacional. Podem ser constantes ou variáveis,
como podem ser vistos a seguir.
3.2 Constantes
Um dado é dito constante quando ele não sofre alterações durante o decorrer do
tempo, ou seja, seu valor é constante desde o início até o final da execução do
programa computacional.
Uma constante pode ser um número, um valor lógico ou uma seqüência de
caracteres quaisquer com algum significado para o problema em estudo. Conforme o
seu tipo, a constante é classificada como sendo numérica, lógica ou literal.
3.2.1 Constante Numérica

A representação de uma constante numérica é feita no sistema decimal,
podendo ser um número com parte fracionária ou não.
Ex.: 25
3.14
7.8E3 {7.8 x 103}
2.5E-3 {2.5 x 10-3}
3.2.2 Constante Lógica

É um valor lógico, isto é, que só pode ser falso ou verdadeiro, usado em
proposições lógicas, conforme será visto mais adiante.
3.2.3 Constante Literal

Uma constante deste tipo pode ser qualquer seqüência de caracteres (letras,
dígitos ou símbolos especiais) com algum significado para o problema em estudo.
Ex.: ‘Francisco P.A. Almeida’
‘12345’
‘*A!B?-’
‘15/05/2006’
29
Nota-se que um numeral escrito como literal é considerado como uma seqüência
de dígitos, e não como uma constante numérica.
3.3 Variáveis
Variável é um espaço (endereço) na memória principal do computador usada
para armazenar um determinado tipo de dado. A uma variável, associa-se um nome
que serve como referência ao dado armazenado nesse espaço na memória.
O conteúdo de uma variável pode ser de diversos tipos: numérico (inteiro e real),
caractere, lógico, e outros. Normalmente, o estudo de algoritmos trabalha com os tipos
acima citados.
Na maioria das linguagens de programação, as variáveis precisam ser
explicitamente declaradas. Na declaração de uma variável, o seu tipo e seu nome
devem ser obrigatoriamente especificados.
Quando uma declaração de variável é encontrada no programa, reserva-se um
espaço na memória para armazenar um dado tipo da variável e associa-se o nome da
variável a este espaço.
Exemplo 01 – Declaração de variáveis

inteiro: a;
real: x;
caracter: s;
logico: l;
a = 5;
x = 8.34;
s = ‘c’;
l = VERDADEIRO;
Deve-se observar que na linguagem MATLAB, não existe uma diferença entre
números inteiros e reais. Eles são tratados de uma mesma forma como variáveis
numéricas. Além disso, o MATLAB não requer a declaração prévia dessas variáveis. Isso
é feito implicitamente quando a variável está sendo usada pela primeira vez no
programa computacional.
30
Exemplo 02 – Variáveis no MATLAB

a = 5; % variável numérica
b = 8.35; % variável numérica
s = ‘c’; % caractere
l = 1; % variável lógica
v = ‘casa’; % seqüência de caracteres (string)
As seguintes regras básicas devem ser atendidas no uso de variáveis no

MATLAB.
• Palavra única (sem espaços);

• Maiúscula ≠ Minúscula;
• Tamanho máximo = 31 caracteres;
• Nome deve ser iniciado com letra;
• Palavras-chave (reservadas da linguagem) não podem ser usadas.
Exemplo 03:
Erro: function é uma palavra-chave
>> function = 8
Exemplo 04: Detalhe interessante

>> A = ‘1’; % caractere
>> B = 1; % valor numérico 1
% A e B são diferentes
3.4 Expressões Aritméticas

Expressões aritméticas são aquelas que cujos operadores são aritméticos e os
operandos são constantes e/ou variáveis do tipo numérico.
Os operadores permitem combinar variáveis e constantes, formando uma
expressão que pode ser avaliada e resultar em um valor.
O conjunto de operações básicas adotado é o que se conhece da matemática, ou
seja:
31
adição subtração
multiplicação divisão
potenciação radiciação
Observação: não é permitido omitir o operador de multiplicação, o que é comum

nas expressões matemáticas. Isto evita confusão quanto aos nomes de variáveis, pois
numa expressão da forma AB+C, como saber se AB é o nome de uma variável ou a
multiplicação de entre os conteúdos de duas variáveis, cujos nomes são A e B?
3.4.1 Operadores Aritméticos

Conjunto de símbolos que representam as operações básicas da matemática. Os
tipos básicos usados no MATLAB são:
Soma +
Subtração –
Multiplicação *
Divisão /
Observação: por uma questão de uniformidade, na elaboração de algoritmos,

não é permitido o uso de outros símbolos para as operações acima, a exemplo de “x” e
“÷” para multiplicação e divisão, respectivamente.
Além destes, existem outros operadores importantes que podem ser usados na
elaboração de programas computacionais.
Potenciação ^
Resto de divisão mod(x,y)
Radiciação sqrt(x)
Outros operadores serão apresentados ao longo do curso.

32
Exemplo 06:
2^3
8
Exemplo 07:
mod(5,3)
2
Exemplo 08:
sqrt(9)
3
Exemplo 08:
>> c = 5 + 3;
Ou
>> a = 3;
>> b = 1;
>> c = 3 + a*b;
Exemplo 09:
>> a = ‘teste’
Erro: não é uma expressão
>> b = a + 2
3.4.2 Prioridades
Existe uma ordem que define a precedência (hierarquia) entre os operadores
aritméticos, como pode ser visto na tabela abaixo:
Parênteses mais internos

^, sqrt
*, /, mod
+, -
33
Exemplo 10:
5 + 9 + 7 + 8/4
5+9+7+2
23
Exemplo 11:
1 + 5 + (2 + 3) * 4
1+5+5*4
1 + 5 + 20
26
3.5 Expressões Lógicas

É comum nos algoritmos surgirem situações em que a execução de uma ação,
ou seqüência de ações, está sujeita a certa condição. Essa condição é representada no
texto do algoritmo por meio de uma expressão lógica.
Assim, expressões lógicas são aquelas cujos operadores são lógicos ou
relacionais e cujos operandos são relações, constantes e/ou variáveis do tipo lógico.
3.5.1 Operadores Relacionais

Os operadores relacionais são usados para realizar comparações entre dois
valores do mesmo tipo. Esses valores podem ser constantes, variáveis ou expressões
aritméticas. O resultado produzido por um operador relacional é sempre um valor
lógico. Como na linguagem C, no MATLAB não existe explicitamente o operador lógico
VERDADEIRO ou FALSO. Se o resultado de uma comparação for falso, produz o valor
zero; caso contrário, valor um.
Os operadores relacionais são conhecidos da Matemática, a saber:
= igual a < menor que

≠ diferente de ≥ maior que ou igual a
> maior que ≤ menor que ou igual a
Os operadores relacionais do MATLAB são:

34
< Menor que

<= Menor que ou igual a
> Maior que
>= Maior que ou igual a
== Igual a
~= Diferente de
Cuidado!
Exemplo 12:
2 * 4 == 24 / 3
8 == 8
1
Exemplo 13:
>> vf = (4*5+3) + 4 == 20/4 + 15;
>> vf
vf = 0
Exemplo 14:
A = 3;
B = 2;
Expressão Relacional
(A + B) > 3
3.5.2 Operadores Lógicos

A Álgebra das Proposições define três conectivos usados na formação de novas
proposições a partir de outras já conhecidas. Estes conectivos são os operadores nas
expressões lógicas, a saber:
e – para a conjunção
ou – para a disjunção
não – para a negação
35
A conjunção de duas proposições é verdadeira se e somente se ambas as

proposições são verdadeiras.
A disjunção de duas proposições é verdadeira se e somente se, pelo menos uma
delas for verdadeira.
Dada uma proposição p qualquer, uma outra proposição, chamada negação de
p, pode ser formada escrevendo-se “É falso que” antes de p ou, se possível, inserindo a
palavra “não” em p.
O resultado obtido de uma expressão lógica é sempre um valor lógico (V ou F).
Os operadores lógicos são utilizados na formação de proposições lógicas
compostas. No MATLAB, tais operadores são representados pelos seguintes comandos:
& e
| ou
~ não
Exemplo 15: (Tabelas-Verdade)
Negação
A Não A
Falso Verdadeiro
Verdadeiro Falso
Conjunção
A B A&B
F F F
F V F
V F F
V V V
Disjunção Não-Exclusiva
A B A ou B
F F F
36
F V V
V F V
V V V
Sejam p e q proposições, as tabelas-verdade podem ser apresentadas

resumidamente como:
p q peq p ou q não p
F F F F V
F V F V V
V F F V F
V V V V F
Exemplo 15:
2 < 5 & 15/3 == 5
v&v
v
2 < 5 | 15/3 == 5
v|v
v
2 < 5 | (~(15/3==5))
v | (~v)
v| f
v
3.5.2 Prioridades
É possível ter mais de um operador lógico na mesma expressão. Em alguns
casos, conforme os valores envolvidos, a ordem em que são efetuadas as operações
lógicas afeta o resultado final. Assim, igualmente ao que acontece nas expressões
aritméticas, também existe uma relação de prioridade entre os operadores lógicos. A
37
tabela 2 apresenta as prioridades entre todos os operadores conhecidos, visto que

podem estar presentes na mesma expressão lógica.
Tabela 2 – Prioridades das operações
Prioridade Operações
1a aritmético
2a relacional
3a não
4a e
5a ou
Também nas expressões lógicas, vários níveis de parênteses podem ser

utilizados com a finalidade de estabelecer uma ordem de execução entre os operadores
lógicos.
3.6 Expressões Literais

Uma expressão literal é aquela formada por operadores literais e operandos que
são constantes e/ou variáveis do tipo literal.
Supondo que A e B são variáveis literais, a operação de concatenação fornece
como resultado um único literal formado pelo conteúdo de A seguido do conteúdo de B.
No MATLAB, isso é feito da seguinte forma:
Exemplo 16:
>>txt=’Resultado’;
>>txt1=[txt ‘ da Prova’]; % Concatenação horizontal
>>txt1=strcat(txt,' da Prova')
txt1 =
Resultado da Prova
38
Exemplo 17:
>>txt=’Resultado’;
>>txt1=[txt; ‘ da Prova’] % Concatenação vertical
A concatenação vertical com sinal ‘;’só foi possível porque as duas cadeias de
caracteres possuem o mesmo tamanho.
Cadeias de caracteres com números diferentes de letras não podem ser
concatenadas com ‘;’:
Exemplo 18:
>> txt1=[txt; 'da Prova']
??? Error using ==> vertcat
All rows in the bracketed expression must have the same
number of columns.
Nesse caso, deve-se usar a função strvcat, que executa a concatenação,

ajustando os tamanhos das cadeias de caracteres com a inclusão de espaços.
Exemplo 19:
>> txt1=strvcat(txt, 'da Prova')
txt1 =
Resultado
da Prova
Além da concatenação de literais, é comum a existência de outras operações

desta natureza. Por exemplo, no MATLAB, a função numel informa o comprimento do
literal, ou seja, o número de caracteres.
Exemplo 20:
>> numel(txt)
ans =
9
39
É possível identificar qualquer caractere de um literal.
Exemplo 21:
>> txt(1)
ans =
R
>> n=numel(txt);
>> txt(n)
ans =
o
O símbolo ‘:’ define intervalos de indexação.
Exemplo 22:
>> txt(1,1:2)
ans =
Re
>> txt(1,3:5)
ans =
sul
>> txt(1,6:7)
ans =
ta
>> txt(1,8:9)
ans =
do
A palavra-chave ‘end’ indica fim de intervalo.

Exemplo 23:
>> txt(1,6:end)
ans =
tado
40
3.7 Comando de Atribuição

Permite fornecer (atribuir) um valor a uma variável. O comando utilizando para
definir esse operador é =.
Exemplo 24:
>> A = 5;
>> B = 4;
>> C = A+mod(A,B);
Deve-se observar que à esquerda do comando de atribuição deve existir apenas

uma variável.
3.8 Comandos de Entrada e Saída

Os algoritmos necessitam da entrada de dados para que possam efetuar as
operações e cálculos a fim de alcançar um resultado desejado (saída de dados).
Os comandos de entrada e saída são as ferramentas que determinam o
momento da entrada dos dados para o programa e a saída dos resultados obtidos pelo
computador.
A finalidade da entrada de dados é atribuir o dado a ser fornecido pelo usuário à
variável identificada. Nos algoritmos, pode-se utilizar a palavra “leia” para a leitura de
variáveis.
leia (x1, x2, x3, ..., xn)
onde x1, x2, x3, ..., xn são variáveis, lidas na mesma linha.
Exemplo:
leia (A);
leia (altura, peso);
No MATLAB, a associação de um valor a uma variável pode ser feita,

basicamente de 3 maneiras, a depender de onde e como a variável é definida:
41
¾ A variável é definida e associada no editor de programas.
Exemplo 1
prova_escrita=8;
prova_pratica=9;
media=(prova_escrita+prova_pratica)/2
¾ A variável é definida e associada na janela de comandos.
Exemplo 2
>> prova_escrita=8;
>> prova_pratica=9;
>> ex2
media =
8.5000
¾ A variável é definida no editor de programas, mas um valor específico é atribuído

na janela de comandos quando o programa é executado.
Exemplo 3
prova_escrita=input('Prova escrita= ');
prova_pratica=input('Prova pratica= ');
Para esse último caso, o comando “input” é utilizado para criar a variável. A
forma do comando “input” é:
nome_da_variavel=input(‘mensagem que é mostrada na janela de comandos’)
A finalidade da saída de dados é exibir o conteúdo da variável identificada.

Mostrar a resposta do problema. A palavra-chave “escreva” é utilizada nos algoritmos.
42
escreva (x1, x2, x3, ..., xn);
Exemplo: escreva (A);

escreva (‘Altura = ’, altura, ‘metros’);
escreva (‘Você tem ’, peso, ‘kilos’);
No MATLAB, dois comandos são muito usados para a saída de dados: “disp” e
“fprintf”. O comando “disp” mostra a saída na tela, enquanto que o comando “fprintf”
pode ser usado para mostrar a saída na tela ou salvar a saída em um arquivo.
O comando “disp” é usado para mostrar os elementos de uma variável sem
mostrar o nome da variável, e para mostrar texto. O formato do comando “disp” é:
disp (nome de uma variável) ou disp(‘texto’)
Apenas uma variável pode ser mostrada em um comando ‘disp’.
Exemplo 4
media=(prova_escrita+prova_pratica)/2;
disp(media);
O comando ‘fprintf’ pode ser usado para mostrar texto e dados na tela ou para
salva-los em um arquivo. Com esse comando (diferentemente do comando ‘disp’) a
saída pode ser formatada.
A utilização do comando ‘fprintf’ para mostrar texto tem a seguinte forma:
fprintf (‘texto’)
43
Exemplo 5
fprintf('Media= ');
disp(media);
Obs.: O comando ‘fprintf’ não inicia uma nova linha.
Outros comandos podem ser utilizados junto com o comando ‘fprintf’:

\n começa uma nova linha;
\b Backspace;
\t tabulação horizontal
A utilização do comando ‘fprintf’ pode ser feita para mostrar uma mistura de
texto e dados numéricos. Isso acontece, por exemplo, da seguinte forma:
fprintf(‘texto % 5.2f texto adicional’, nome da variável);
onde o símbolo ‘%’ marca onde o número entra no texto; no exemplo, ‘5.2f’ é a
formatação da variável, no caso, são 5 dígitos, com 2 casas decimais e formatação com
ponto fixo. Outros exemplos são:
e notação exponencial com letra minúscula;

E notação exponencial com letra maiúscula;
f notação com ponto fixo;
i inteiro.
Exemplo 6
fprintf('\nMedia=%6.2f',media);
44
O comando ‘fprintf’ permite inserir mais de uma variável dentro do texto:
fprintf(‘texto %...%...’, variável1,variável2);
3.9 Blocos
Um bloco pode ser definido como um conjunto delimitado de ações a serem
executadas.
Para delimitar um bloco em um algoritmo, são utilizados delimitadores:
início
fim
4 Estruturas de Controle
Na construção de algoritmos, utilizamos os conceitos de:

9 variáveis
9 constantes
9 atribuições
9 operadores e expressões aritméticas, lógicas e relacionais
9 comandos que traduzem esses conceitos de forma a representar o
conjunto de ações desejadas.
Para que esse conjunto de ações se torne viável, é necessário estabelecer o fluxo
de execução do algoritmo.
Isso é possível a partir do uso das estruturas básicas de controle do fluxo de
execução e das combinações entre elas, permitindo a criação de algoritmos e
programas computacionais usados na solução dos problemas. Essas estruturas são
apresentadas na presente seção.
4.1 Estruturas Seqüenciais

Correspondem à execução do conjunto de ações primitivas em uma seqüência
linear de comandos de cima para baixo e da esquerda para direita (ou seja, na mesma
ordem em que foram escritas).
45
Exemplo 01: Calcular a média aritmética de quatro notas semestrais

quaisquer fornecidas por um aluno.
N1 = input(‘Entre com a nota 1: ’);
MA = (N1+N2+N3+N4)/4;
disp(‘A media e: ’);
disp(MA);
Neste exemplo, deve-se observar que o fluxo de execução é de cima para baixo,
da esquerda para a direita.
Exemplo 02: Fazer um programa que leia os coeficientes de uma equação do

primeiro grau do tipo y = Ax + B e calcule a sua raiz. Imprimir o resultado na
tela (questão da lista).
A = input(‘Coeficiente A: ‘);
B = input(‘Coeficiente B: ‘);
x = -B/A;
disp(‘A raiz e: ‘);
disp(x);
Exemplo 03: O cálculo do ponto de interseção entre duas retas pode ser
obtido igualando-se as suas equações. Baseado nessa informação, fazer um
programa que leia os coeficientes das equações das retas e calcule o ponto
de interseção. As retas são definidas pelas equações y = Ax+B e y = Cx + D.
Imprimir o resultado.
A = input(‘Coeficiente A: ‘);
B = input(‘Coeficiente B: ‘);
C = input(‘Coeficiente C: ‘);
D = input(‘Coeficiente D: ‘); Ax+B = Cx + D; (A-C)x=(D-B)
x = (D-B)/(A-C);
y = Ax + B;
x=(D-B)/(A-C)
disp(‘Coordenada X: ‘);
disp(x);
disp(‘Coordenada Y: ‘); y=Ax+B
disp(y);
Exemplo 04: Fazer um programa para calcular a norma do vetor x = (x1, x2,
x3), onde os coeficientes devem ser lidos.
x1 = input(‘Coeficiente 1: ‘);
n = sqrt(x1*x1 + x2*x2 + x3*x3);
disp(‘A norma e: ‘);
disp(n);
46
4.2 Estruturas de Controle de Fluxo

As estruturas de controle de fluxo são fundamentais para qualquer linguagem de
programação. São estruturas que alteram o fluxo de execução do programa. Sem elas
só haveria uma maneira do programa ser executado: de cima para baixo comando por
comando. Não haveria condições, repetições ou saltos.
A linguagem MATLAB possui diversos comandos de controle de fluxo. É possível
resolver todos os problemas sem utilizar todas elas, mas deve-se notar que a elegância
e facilidade de entendimento de um programa dependem do uso correto das estruturas
nos locais certos.
4.2.1 Estruturas de Seleção (Condicional)

Essas estruturas permitem a escolha de um grupo de comandos a ser executado
quando determinadas condições são ou não satisfeitas (verdadeiro ou falso). Aqui, são
usados os conceitos de expressões lógicas e relacionais vistos anteriormente.
4.2.1.1 Seleção Simples

Usada quando precisamos testar uma certa condição antes de executar uma
ação. Seu modelo é descrito abaixo.
Expressão Lógica
if < condição >
e/ou relacional
comando 1;
comando 2;
comando n;
end
Exemplo 01: Cálculo da média com verificação de aprovação.

MA = (N1+N2+N3+N4)/4;
disp(MA);
If( MA >= 7 )
disp(‘Aluno aprovado!’);
end
47
4.2.1.2 Seleção Composta

Usada quando existir situações em que duas alternativas dependem de uma
mesma condição (uma ser verdadeira e outra falsa).
Expressão
if < condição é verdadeira >
Ló i /
comando a-1;
comando a-2;
comando a-n;
else
comando b-1;
comando b-2;
comando b-n;
end
Exemplo 02: cálculo da média com verificação de aprovação e reprovação.

MA = (N1+N2+N3+N4)/4;
disp(MA);
if( MA >= 7 )
Else
disp(‘Aluno reprovado!’);
End
48
4.2.1.2 Seleção Encadeada

Usada quando existe a necessidade de agrupar várias seleções de forma
encadeada.
if < condição1 >

comando a-1;
comando a-2;
comando a-n;
elseif < condição 2 >
comando b-1;
comando b-2;
comando b-n;
elseif < condição 3 >
if < condição 3-a >
comando c-1;
comando c-2;
comando c-n;
end
else
comando d-1;
comando d-2;
comando d-n;
end
Exemplo 03: cálculo da média verificando aprovação, reprovação e final.

MA = (N1+N2+N3+N4)/4;
disp(MA);
if( MA >= 7 )
elseif( MA < 5 )
disp(‘Aluno reprovado!’);
else
disp(‘Aluno na final’);
end
49
4.2.1.4 Seleção de Múltipla Escolha

Esse tipo de seleção é uma alternativa para o uso da seleção encadeada if-else-
if.
switch( variavel )
case v1:
comandos 1;
case v2:
comandos 2;
case vn:
comandos n;
otherwise:
comandos;
end
Deve observar que variável não pode ser uma expressão.
Exemplo 04:
disp(‘digite 1: primeira opcao’);
disp(‘digite 2: segunda opcao’);
disp(‘digite 3: terceira opcao’);
case 1:
disp( ‘Foi digitada a primeira opcao’);
case 2:
disp( ‘Foi digitada a segunda opcao’);
case 3:
disp( ‘Foi digitada a terceira opcao’);
Otherwise:
disp( ‘Opcao nao existente’);
End
4.2.1.5 Exercícios
Exercício 01: Escrever um algoritmo que leia 3 valores numéricos e mostre-os
em ordem crescente.
A = input(‘Valor 1: ’);
B = input(‘Valor 2: ’);
C = input(‘Valor 3: ’);
if( A < B )
if( B < C )
disp(A); disp(B); disp(C);
else
if( A < C )
disp(A); disp(C); disp(B);
else
50
disp(C); disp(A); disp(B);

end
end
elseif( A < C)
disp(B); disp(A); disp(C);
else
if( B < C )
disp(B); disp(C); disp(A);
else
disp(C); disp(B); disp(A);
end
end
Exercício 02 – Ler 3 números, verificar se eles podem ou não ser lados de um

triângulo. Se sim, classificar o triângulo quanto os seus lados.
3 lados iguais: Eqüilátero
2 lados iguais: Isósceles
Lados desiguais: Escaleno
A = input(‘Entre c/ o primeiro lado: ’);
B = input(‘Entre c/ o segundo lado: ’);
C = input(‘Entre c/ o terceiro lado: ’);
if( A < B+C & B < A+C & C < A+B )
if A == B & B == C
disp(‘Triangulo Eqüilátero!’);
elseif A == B | B == C | A == A
disp(‘Triangulo Isósceles!’);
else
disp(‘Triangulo Escaleno!’);
end
else
disp(‘Lados nao formam um triangulo!’);
end
Exercício 03 – Criar um algoritmo que entre com o valor de x, calcule e

imprima o valor de f(x), onde
f(x) = (5x+3) / sqrt(x2 – 16)
x = input(‘Entre c/ o valor de x: ’);
d = x^2 – 16;
if d <= 0
disp( ‘Nao existe solucao real!’ );
else
f = (5x+3)/sqrt(d);
disp(‘O valor de f e’: ’);
disp(f);
end
51
Exercício 04 – Escrever um programa que verifique se um dado número é par

ou ímpar (entre 0 e 100).
A = input(‘Entre c/ o numero: ’);
if A < 0
disp(‘O numero e menor que zero!’);
elseif A > 100
disp(‘O numero e maior que zero!’);
else
if mod(A,2) == 0
disp(‘O numero e par!’);
else
disp(‘O numero e impar!’);
end
end
4.3 Estruturas de Repetição

Considere o seguinte algoritmo para o cálculo da média bimestral de um aluno:
Exemplo 07:
P1 = input(‘Nota do trabalho: ’);
P2 = input(‘Nota da prova: ’);
Media = 0.3*P1 + 0.7*P2;
disp(Media);
E se eu desejar calcular a média de todos os alunos da turma? (21, por exemplo)

Uma solução é repetir o código acima 21 vezes; outra opção é “rodar” (executar) o
programa acima 21 vezes.
No entanto, nem sempre essas soluções são viáveis.
A idéia, então, é usar o mesmo trecho do código acima sem a necessidade de
reescrevê-lo. As estruturas usadas para implementar essa idéia são chamadas
Estruturas de Repetição. Elas podem ser divididas em dois tipos básicos:
9 Estruturas de Repetição Definidas

9 Estruturas de Repetição Indefinidas
Essas estruturas são vista na seqüência desta seção.
4.3.1 Estruturas de Repetição Definidas

São estruturas de repetição com um número finito de repetições. Sua sintaxe é
dada por:
52
para i de vi até vf de passo p faça

comando 1;
comando 2;
M
comando n;
fim
i = variável de controle;
vi = valor inicial atribuído a i;
vf = valor final atribuído a i (condição de parada);
p = incremento/decremento dado à variável i.
Exemplo 01: Calcular a média anual de 10 alunos.

s = 0;
for i = 1:1:10
m = input(‘media: ‘);
s = s + m;
end
media = s / 10;
disp(media);
O funcionamento do código acima é dado pela tabela abaixo:
i m s
1 10 10
2 5 15
3 5 20
4 8 28
5 7 35
6 10 45
7 5 50
8 6 56
9 4 60
10 3 63
53
Ao final da execução, a variável média vai armazenar o valor 63/10 = 6.3.

Se o valor do incremento (p) é omitido, considera-se p=1 (for i = 1:10).
Se vi = vf, o “laço” é executado uma vez.
Se vi > vf e p > 0 ou se vi < vf e p < 0, o laço não é executado.
Exemplo 02: Calcular a soma dos 6 primeiros números pares não-negativos.

soma = 0;
for i = 0:2:10
soma = soma + i;
end
disp(soma);
Ou
soma = 0;
for i = 0:1:5
soma = soma + 2*i;
end
disp(soma);
E se desejássemos calcular a soma dos 100 primeiros números pares não-

negativos? A alteração seria apenas no limite da estrutura de repetição. Isso mostra a
importação desse tipo de estrutura.
Exemplo 03: Calcular a média bimestral de 10 alunos.

for i = 1:1:10
p1 = input(‘Nota do Trabalho: ’);
p2 = input(‘Nota da Prova: ’);
media = 0.3*p1 + 0.7*p2;
disp(‘Media’);
disp(media);
end
Exemplo 04: Dado um número qualquer, calcular o seu fatorial.

x = input(‘Entre com um numero: ‘)
fat = 1;
for i = 1:1:x
fat = fat * i;
end
Disp(fat);
54
4.3.2 Estruturas de Repetição Indefinidas

São estruturas onde não se conhece, a priori, quantas execuções serão
realizadas. Sua sintaxe é dada por:
enquanto ( expressão condicional)

comando 1;
comando 2;
M
comando n;
fim
onde expressão condicional representa a condição de execução do bloco.
No Matlab,
while ( expressão condicional)

comando 1;
comando 2;
M
comando n;
end
Exemplo 01: Calcular o valor de f(x) = x2 + 2 até que f(x) seja maior que 20.
f = 0;
while f <= 20
x = input(‘Entre com x: ’);
f = x^2 + 2;
disp(f);
end
As estruturas de repetição indefinida também podem ser usadas em problemas

definidos. No entanto, o inverso não é verdade.
55
Exemplo 02: Calcular a média anual de 10 alunos usando while.

soma = 0;
cont = 1;
while cont <= 10
m = input(‘Media: ’);
soma = soma + m;
cont = cont + 1;
end
media = soma/(cont – 1);
disp(media);
4.3.2.1 Exercícios
Exercício 01: Jogo do Adivinha: Escolher um número de 0 a 100. Tente
adivinhar o número gerado. A cada tentativa, deve-se informar mais baixo,
mais alto ou acertou. Quando acertar, mostrar o número de tentativas.
Obs.: O comando randint(1,1,[0,100]) deve ser usado para gerar um
número inteiro aleatório.
teste = 0;
soma = 0;
segredo = randint(1,1,[0,100]);
while teste == 0
chute = input(‘Entre com um numero: ‘);
soma = soma + 1;
if chute == segredo
teste = 1;
disp(‘Acertou’);
disp(‘Tentativas: ‘);
disp(soma);
elseif chute < segredo
disp( ‘Mais alto...’);
else
disp(‘Mais baixo…’);
end
end
Exercício 02: Jogo do Adivinha 2: O usuário pensa em um número entre 0 e

100 e executa o programa. O computador “chuta” um valor. A cada chute,
deve-se informar se o computador acertou, mais alto ou mais baixo. Ao final,
deve-se informar o número de tentativas chutadas pelo computador.
teste = 0;
soma = 0;
segredo = input(‘Entre com um numero: ‘);
if segredo >= 0 & segredo <= 100
Min = 0;
Max = 100;
while teste == 0
chute = randint(1,1,[Min,Max]);
56
soma = soma + 1;
disp(‘Numero Chutado: ‘);
disp(chute);
if chute == segredo
teste = 1;
disp(‘Acertou’);
disp(‘Tentativas: ‘);
disp(soma);
elseif chute < segredo
disp( ‘Mais alto...’);
Min = chute;
else
disp(‘Mais baixo…’);
Max = chute;
end
end
end
Exercício 03: Calcule o valor do cosseno de x (em radianos) usando os 20

primeiros termos da série
x2 x4 x6 x8
cos( x) = 1 − + − + + ...
2! 4! 6! 8!
x = input(‘Entre com o valor do ângulo: ‘);
c = 0;
sinal = 1;
for i = 0:1:19
fat = 1;
for j = 1:1:2*i;
fat = fat * j;
end
c = c + sinal * x^(2*i)/fat;
sinal = -1 * sinal;
end
disp(c);
Exercício 04: Fazer um programa seguindo as seguintes orientações:

a) Leia os parâmetros A e B da equação da reta dada por y = Ax+B;
b) Leia os parâmetros C, D e R da equação do círculo dada por
Cx2+Dy2=R2;
c) Leia as coordenadas (x,y) e verifique se esse ponto é um dos pontos
de interseção entre a reta e o círculo dados. Um ponto é de interseção
se ele atender as equações das curvas dadas.
A = input(‘Entre com o parâmetro A: ‘);
B = input(‘Entre com o parâmetro B: ‘);
C = input(‘Entre com o parâmetro C: ‘);
D = input(‘Entre com o parâmetro D: ‘);
R = input(‘Entre com o parâmetro R: ‘);
57
x = input(‘Entre com a coordenada X do ponto: ‘);

y = input(‘Entre com a coordenada Y do ponto: ‘);
If A*x + B == y & C*x^2 + D*y^2 == R^2
disp(‘Ponto de intersecao.’);
end
5 Estruturas de Dados
5.1 Introdução
Nas seções anteriores, foi feita uma divisão imaginária (numérico, caractere e
lógico) com o objetivo de tornar mais simples a classificação das informações (dados)
de um programa.
No entanto, em muitas situações, esses recursos são escassos. Esta seção
descreve novos tipos de dados que são construídos e organizados a partir da
composição dos tipos primitivos vistos anteriormente. Esses novos tipos são conhecidos
como Estrutura de Dados e são classificados da seguinte forma:
• Estrutura de Dados
o Variáveis Compostas Homogêneas;
Unidimensionais (Vetores);
Multidimensionais (Matrizes).
o Variáveis Compostas Heterogêneas
Registros
Essas novas variáveis são descritas na seqüência desta seção.
5.2 Variáveis Compostas Homogêneas

São estruturas de dados compostas de variáveis do mesmo tipo primitivo, como
podem ser vistos nos exemplos abaixo:
3
Caractere
8.5
7
5
C A R R O
58
A variável é o todo (ou seja, o conjunto). Cada termo da variável é chamado de

elemento. Em ambos os exemplos, cada elemento tem o mesmo tipo primitivo
(números e caracteres). Daí a denominação “homogêneo”. Uma string (cadeia de
caracteres) é uma variável composta homogênea.
Os exemplos acima são variáveis compostas unidimensionais (também chamadas
de vetores).
O exemplo abaixo também ilustra uma variável composta homogênea. No
entanto, ela é classificada como uma variável composta multidimensional (conhecida
como matriz).
1 0 4
5 2 1
7.5 3 1
O exemplo abaixo ilustra o exemplo de uma variável composta que não é

classificada como homogênea.
C 3 5 1 L
5.2.1 Variáveis Compostas Homogêneas Unidimensionais

São estruturas de dados compostas de elementos do mesmo tipo primitivo e
armazenados em matrizes linha ou coluna. O exemplo abaixo ilustra a criação de um
vetor no MATLAB.
Exemplo 01:
>> A=(0:2:10)
>> B=ones(2,3)
>> C=zeros(3,2)
O exemplo acima produz o seguinte vetor:
A=
0 2 4 6 8 10
59
B=
1 1 1
1 1 1
C=
0 0
0 0
0 0
A seguir, é mostrado outro exemplo para ilustrar o uso de vetores.
Exemplo 02:
>> % imprime o segundo elemento do vetor. 2 é o índice do vetor.
>> disp(A(2));
>> % Alterando o terceiro elemento do vetor.
>> A(3) = 10;
for i = 1:10
1, 3, 5, 7, 9, …,
A(i) = 2*i – 1;
end
disp(A);
Mas para que servem os vetores? Os exemplos abaixo servirão para responder
tal questão.
Exemplo 03:
% a) Cálculo da média aritmética de 10 notas
soma = 0;
for i = 1:10
x = input(‘Entre com a nota: ’);
soma = soma + x;
end
media = soma / 10;
% b) Quais notas são maiores que a média?
A1 = input(‘Nota 1: ’);
.
.
.
media = (A1 + A2 + ... + A10) / 10;
if A1 > media
disp( A1 );
60
end
if A2 > media
disp( A2 );
end
.
.
.
Mas e se tivéssemos 100 notas? A solução acima seria inviável. O exemplo

abaixo usa vetor para resolver o mesmo problema.
Exemplo 04: Exemplo anterior usando vetores

soma = 0;
for i = 1:10
nota(i) = input(‘Entre c/ a nota: ’);
soma = soma + nota(i);
end
media = soma / 10;
for i = 1:10
if nota(i) > media
disp(nota(i));
end
end
Exemplo 05: Fazer um programa que leia, some e imprima o resultado da

soma entre dois vetores de 10 posições.
for i = 1:10
A(i) = input(‘valor armazenado no vetor A: ’);
B(i) = input(‘valor armazenado no vetor B: ’);
C(i) = A(i) + B(i);
end
disp( C );
Exemplo 06: Fazer um programa que preencha um vetor de 100 elementos

colocando 1 na posição correspondente a um número par e 0 a um número
ímpar.
for i = 1:100
if mod(i,2) == 0
a(i) = 1;
else
a(i) = 0;
end
end
disp(a);
61
Exemplo 07: Seja o vetor V = {2, 6, 8, 3, 10, 9, 1, 21, 33, 14}. Seja também x = 2 e y
= 4.
V(x+1) V(3) = 8
V(x+2) V(4) = 3
V(x*4) V(8) = 21
V(V(x+y)) V(V(6)) = V(9) = 33
V(x+y) V(6) = 9
V(V(1)*V(4)) V(2*3) = V(6) = 9
Exemplo 08: Fazer um programa que leia um vetor de 10 posições e coloque-

o em ordem crescente, utilizando a seguinte estratégia:
• Selecione o elemento do vetor que apresenta o menor valor;
• Troque este elemento pelo primeiro;
• Repita essas operações envolvendo agora apenas os 19 elementos
restantes, até restar um único elemento.
for i = 1:10
a(i) = input(‘A: ’);
end
for j = 1:10
% inicializacao
menor = a(j);
posicao = j;
% selecionando o menor
for i = j:10
if a(i) < menor
menor = a(i);
posicao = i;
end
end
% troca
aux = a(j);
a(j) = menor;
a(posicao) = aux;
end
disp(a);
Sobre o exemplo acima, as seguintes questões devem ser observadas:
a) A variável “posição” armazena a posição do menor valor;

b) Uso de uma variável auxiliar “aux” para fazer a troca de 2 números.
62
5.2.2 Variáveis Compostas Homogêneas Multidimensionais

São estruturas de dados compostas de elementos do mesmo tipo primitivo e
armazenados em formato matricial.
O Exemplo abaixo ilustra a diferença entre vetores e matrizes:
• Vetores
o Um índice (unidimensional) para endereçamento
A(1) = 3;
A(2) = 7;
• Matrizes
o Dois índices (bidimensional) para endereçamento
A(1,1) = 1;
A(2,1) = 5;
A(1,2) = 4;
A(2,2) = 3;
1 4
5 3
Nesse exemplo,
• A é uma matriz bidimensional 2x2;

• A é uma variável;
• Cada termo de A é um elemento.
Para acessar um elemento de uma matriz precisamos de dois índices. O primeiro

índice corresponde à linha da matriz; o segundo a coluna.
63
A(i,j) ⇒ linha i, coluna j
>> A(3,4) = 2;
Aqui, o valor 2 é atribuído ao elemento correspondente a linha 3, coluna 4 da

matriz A.
1 2 3 4
1
2
3 2
Alguns detalhes devem ser observados:
a) Uma matriz é um conjunto de vetores;

b) Para utilizarmos um vetor, manipulamos um único laço de repetição;
c) Para utilizarmos uma matriz, manipulamos tantos laços de repetição quanto forem
suas dimensões (bidimensional = 2 laços; tridimensional = 3 laços, etc).
Exemplo 09: Construir um programa para ler duas matrizes, efetuar a sua
soma e imprimir o resultado.
for i = 1:5
disp(‘linha’);
disp(i);
for j = 1:5
a(i,j) = input(‘a: ’);
b(i,j) = input(‘b: ’);
c(i,j) = a(i,j) + b(i,j);
end
end
disp(c);
64
Exercícios
Exercício 01: Construir um programa para ler uma matriz e calcular a sua
transposta.
for i = 1:5
for j = 1:5
A(i,j) = input(‘A: ‘);
end
end
for i = 1:5
for j = 1:5
B(i,j) = A(j,i);
end
end
disp(B);
Exercício 02: Fazer um programa que leia os elementos de uma matriz 5x5 e
calcule o seu traço (soma dos elementos da diagonal principal).
for i = 1:5
for j = 1:5
end
end
traco = 0;
for i = 1:5
traco = traco + A(i,i);
end
disp(traco);
Exercício 03: Fazer um programa que calcule o produto de 2 matrizes.

A = 3x2
B = 2x4
for i = 1:3
for j = 1:2
end
end
for i = 1:2
for j = 1:4
B(i,j) = input(‘B: ‘);
end
end
for i = 1:3
for j = 1:4
C(i,j) = 0;
for k = 1:2
C(i,j) = C(i,j) + A(i,k) * B(k,j);
end
end
end
65
5.3 Variáveis Compostas Heterogêneas

São variáveis compostas por diferentes tipos primitivos (veja os exemplos
abaixo).
Heterogênea (1, 2, ‘Carro’, ‘Alagoas’, 3.55)
Homogênea (0, 4, 30, 20)
Exemplo:
Passagem de ônibus – Formada por um conjunto de informações logicamente
relacionadas, mas de tipos diferentes.
• Número da passagem (numérico);
• Origem e Destino (caracteres);
• Data (caracteres);
• Horário (numérico); Campos
• Poltrona (numérico);
d
• Distância (numérico);
• Fumante (lógico: verdadeiro ou falso).
Alguns detalhes que devem ser observados:
a) Variável do tipo registro: passagem de ônibus;

b) Cada campo do registro deve possuir um nome associado a ele.
Exemplo 01:
% criando um registro (variável) chamado de B
B = { };
% criando os campos da variável B e atribuindo valores a eles
B.marca = ‘Fiat’;
B.tipo = ‘Palio’;
B.cor = ‘Preto’;
B.ano = 2004;
B.placa = ‘xyw1030’;
disp(B);
Exemplo 02: Fazer um programa para ler informações escolares de um aluno

e armazená-las em um registro. Os dados do aluno são: nome, idade, número
da matrícula e série que está cursando.
Aluno = { };
Aluno.nome = input(‘Nome: ’, ‘s’);
Aluno.idade = input(‘Idade: ’);
Aluno.matri = input(‘Matricula: ’, ‘s’);
Aluno.serie = input(‘Serie: ’);
disp(Aluno);
66
E se nós desejarmos armazenar informações sobre vários alunos? Isso pode ser
feito a partir da composição (combinação) entre variáveis compostas homogêneas e
heterogêneas.
registro 1
registro 2
registro 3
registro 4
Exemplo 03:
for i = 1:4
aux = { };
aux.nome = input(‘Nome: ’,’s’);
aux.idade = input(‘Idade: ’);
aux.matri = input(‘Matricula: ’);
aux.serie = input(‘Serie: ’);
aluno(i) = aux;
end
for i = 1:4
disp(aluno(i));
end
1 registro 1
2 registro 2
3 registro 3
4 registro 4
Exercícios
Exercício 01: Fazer um programa que leia 5 números e armazene-os em um

vetor. Criar um outro vetor contendo os números múltiplos de 3. Imprimi-los.
for i = 1:5
v(i) = input(‘Entre com o valor: ’);
end
j = 0;
for i = 1:5
if mod(v(i),3) == 0
j = j + 1;
w(j) = v(i);
end
67
end
% nao existe multiplos de 3
if j == 0
disp(‘Nao existe multiplos de 3!’);
else
disp(w);
end
Exercício 02: Fazer um programa que leia um vetor A com 5 elementos e

construa um vetor B da seguinte forma:
Ex.: A = (3, 8, 4, 2, 5)
B = (9, 4, 2, 1, 15);
for i = 1:5
A(i) = input(‘Entre com A: ’);
end
for i = 1:5
if mod(A(i),2) == 0
B(i) = A(i) / 2;
else
B(i) = 3*A(i);
end
end
disp(B);
Exercício 03: Fazer um programa que leia 2 matrizes 2x3 e calcule uma
terceira matriz dada pela expressão R = 2*At-Bt.
for i = 1:2
for j = 1:3
A(i,j) = input(‘A: ’);
end
end
for i = 1:2
for j = 1:3
B(i,j) = input(‘B: ’);
end
end
for i = 1:2
for j = 1:3
AT(j,i) = A(i,j);
BT(j,i) = B(i,j);
end
end
for i = 1:3
for j = 1:2
R(i,j) = 2*AT(i,j) – BT(i,j);
end
end
disp( R );
68
Exercícios 04: Fazer um programa para ler e armazenar informações sobre n

alunos. As informações são: nome, média, aprovado (‘S’ ou ‘N’) e sexo (‘M’ ou
‘F’). Pede-se ainda para imprimir o número de mulheres aprovadas.
n = input(‘Numero de alunos: ’);
for i = 1:n
aluno = { };
aluno.nome = input(‘Nome: ’, ‘s’);
aluno.media = input(‘Media: ’);
aluno.aprov = input(‘Aprovado (S/N): ’, ‘s’);
aluno.sexo = input(‘Sexo (M/F): ’, ‘s’);
turma(i) = aluno;
end
num = 0;
for i = 1:n
if turma(i).aprov == ‘S’
if turma(i).sexo == ‘F’
num = num + 1;
end
end
end
disp( num );
6 Modularização
6.1 Introdução
Uma técnica para resolver problemas complexos é a decomposição do problema
em vários subproblemas.
Problemas Complexos
Técnicas
Decomposição em subproblemas
Algumas vantagens são:
• Dividir a complexidade do problema original, simplificando a sua resolução;

• Focalizar a atenção em problemas menores de cada vez, permitindo uma melhor
compreensão do todo.
O critério adotado neste curso é baseado na seguinte técnica:

69
• Dividir o problema em suas partes principais;

• Analisar a divisão;
• Se alguma parte ainda estiver complexa, decompô-la também;
• Analisar o resultado, garantindo entendimento e coerência.
6.2 Módulos (Funções)

Após a decomposição do problema, pode-se construir subalgoritmos ou módulos
para cada subproblema obtido. Esses módulos são as chamadas funções.
Exemplo: Gerenciamento Salarial

a) Dados
• Nome
• Ano Base
• Salário/Mês
• Salário/Ano (incluindo o 13o)
b) Pede-se
• Cálculo salário/dia (20 dias/mês)
• Cálculo salário/hora (8 horas/dia)
• Novo salário com aumento baseado no índice da inflação
• Classificação em classes sociais (A, B, C, D e E)
c) Saída (Resultados)
• Nome
• Salário/Dia
• Salário/Hora
• Novo salário
• Classe Social
Quando temos um problema complexo, como visto acima, a idéia é, então,

dividi-lo (decompor) em vários subproblemas, utilizando módulos (funções) para
representar, no algoritmo, a decomposição do problema.
Construir um módulo significa construir um algoritmo em instâncias menores. O
problema do exemplo acima terá 3 módulos:
Problema
Entrada Cálculos Saída
Sal./Dia Sal./Mês Novo Sal. Classe Social

70
Módulo 1 ⇒ Entrada dos dados

Módulo 2 ⇒ a) Cálculo do Novo Salário;
b) Salário/Dia
c) Salário/Mês
d) Classe Social
Módulo 3 ⇒ Saída dos dados
Exemplo 01: Entrada de dados da forma convencional

func = { };
func.nome = input(‘Nome: ’, ‘s’);
func.ano = input(‘Ano: ’);
func.sal_mes = input(‘Salario Mensal: ’);
func.sal_ano = input(‘Salario Anual: ’);
Exemplo 02: Entrada de dados usando função

function f = entrada
f = { };
f.nome = input(‘Nome: ’, ‘s’);
f.ano = input(‘Ano: ’);
f.sal_mes = input(‘Salario Mensal: ’);
f.sal_ano = input(‘Salario Anual: ’);
Os exemplos são equivalentes. Apenas no caso 2 foi criada uma função para ler
os dados do problema.
Alguns detalhes que devem ser observados no MATLAB:
• Uma função é identificada pela palavra-chave function;

• Todas as funções têm um nome associado. Neste exemplo, o nome é entrada;
• Cada função deve ser armazenada em um arquivo M separado (um arquivo para
cada função);
• O nome do arquivo deve ser igual ao nome da função armazenada nele. No
exemplo acima, o arquivo deve se chamar entrada.m;
• A variável f, que é um registro, só é válida dentro da função entrada. Dizemos
que ela é uma variável local.
Resumindo:
71
Nome da função
function entrada
Palavra-chave
- obrigatória
Em um projeto maior, também seria necessário criar funções para imprimir os

dados, fazer cálculos numéricos, etc.
Existe, então, a necessidade de “ligar” as várias funções do programa. Isso pode
ser feito no módulo principal do programa.
Chamar a função entrada
Módulo Principal Chamar a função calculos
Chamar a função imprime
Exemplo: Módulo principal

function entrada
. Salvar no arquivo
.
. entrada.m
function imprime
. Salvar no arquivo
.
. imprime.m
% modulo principal Salvar em qualquer arquivo. Este é o

entrada;
imprime; módulo que deve ser executado.
A execução interna do programa segue as diretrizes abaixo:
• Linha 1 – comentário
• Linha 2 – chama (executa) a função entrada
o Executa todos os comandos dessa função
• Linha 3 – chama a função imprime
o Executa todos os comandos dessa função
72
Todas as variáveis criadas dentro de uma função só podem ser usadas na

própria função. Elas não existem fora deste contexto.
Exemplo: Uso de Variáveis Locais

function teste
a=3; Salvar no arquivo
b=2;
c=a*b; teste.m
function imprime
disp(a); Salvar no arquivo
disp(b);
disp(c); imprime.m
% modulo principal Erro: a, b e c não existem em

teste; “imprime”.
imprime;
A solução para resolver problemas como este é o uso de Argumentos de Funções

e Valores de Retorno de Funções.
Alguns comandos usados até agora são, na realizada, funções pré-definidas pelo
próprio Matlab. Como exemplo, podemos citar as funções disp, input, sqrt, mod, sin,
cos, log, etc.
Uma função interessante é a função plot. Ela pode ser usada para fazer gráficos
usando o Matlab.
Exemplo: Uso da função plot

X = [1, 5, 3];
Y = [2, 2, 4];
plot(X,Y);
6.3 Argumentos (Parâmetros) de Funções

São as entradas que as funções vão receber. São através delas que passamos
parâmetros para as funções.
Exemplo 01: Fazer um programa, usando funções, para calcular e imprimir o

produto de dois números
% arquivo ‘produto.m’
function produto(a,b)
73
c = a*b;
disp(c);
% arquivo principal: ‘teste.m’

produto(3,5);
produto(2,3);
x = input(‘X: ‘);
y = input(‘Y: ‘);
produto(x,y);
Resumindo,
Nome da função (obrigátorio)

function nome(a,b,...)
Argumentos (opcional)
-
Palavra-chave (obrigatória)
Notas:
a. a, b e c são variáveis locais;
b. Na primeira chamada da função produto, o valor 3 é copiado para a variável
local a e o valor 5 para b;
c. As variáveis x e y são validas apenas no módulo principal. Elas não podem ser
acessadas dentro da função produto;
d. Uma função pode ser chamada n vezes;
e. O número de argumentos de uma função deve ser compatível entre a sua
definição e a sua execução.
Mas é desejável que exista uma função especifica para imprimir separadamente
o valor do produto.
Se fizermos,
function produto(a,b)
c = a*b;
% arquivo ‘imprime.m’
function imprime
disp(c);

x = input(‘Numero: ’);
74
y = input(‘Numero: ’); Erro: A variável c não está declarada

produto(x,y);
imprime; em imprime.
A solução para resolver o problema acima é a utilização de Valores de Retorno

de Funções.
6.4 Valores de Retorno de Funções

Permite que determinadas informações geradas dentro de uma função possam
ser retornadas por ela.
Exemplo: Fazer um programa para calcular e imprimir o produto de dois

números.
function c = produto(a,b)
c = a*b;
function imprime(a,b,c)
disp(a);
disp(b);
disp(c);

x = input(‘Numero: ‘);
y = input(‘Numero: ‘);
z = produto(x,y);
imprime(x,y,z);
Resumindo,
Nome da função (obrigátorio)

function c = nome(a,b,...)
Argumentos (opcional)
Palavra-chave
- (obrigatória)
Valor de Retorno (opcional)
Notas:
a. x, y e z são variáveis locais no módulo principal;
b. z armazena uma cópia do valor de retorno da função produto;
75
c. a, b e c são variáveis locais na função produto;

d. a, b e c são variáveis locais na função imprime;
e. essas variáveis contém valores diferentes em ambas as funções.
Exercícios
Exercício 01 – Implemente uma função para calcular a área de um triângulo.
Essa função recebe como argumentos a base e a altura do triângulo
correspondente. Escreva o módulo principal.
% arquivo ‘area.m’
function a = area(b, h)
a = 0.5 * b * h;
% modulo principal ‘teste.m’

a1 = area(3,4);
disp(a1);
a2 = area(1,2);
disp(a2);
Exercício 02: Fazer um programa que leia 3 números e armazene-os em um

vetor. Calcular um novo vetor gerado pelos fatoriais desses números.
Imprimir ambos os vetores.
% modulo 1 – ‘entrada.m’
function v = entrada
for I = 1:3
v(i) = input(‘ V: ’);
end
% modulo 2 – ‘fatorial.m’
function f = fatorial( v )
for i = 1:3
fat = 1;
for j = 1:v(i)
fat = fat * j;
end
f(i) = fat;
end
% modulo 3 – ‘saida.m’
function saida( v, f )
for I = 1:3
disp(v(i));
disp(‘factorial :’)
disp(f(i));
end
% modulo principal – ‘exem.m’

x = entrada;
76
y = fatorial(x);
saida(x,y);
Exercício 03 – Exercício 01 modificado

% arquivo ‘entrada.m’
function [a,b] = entrada
a = input( ‘Entre com a base: ‘);
b = input( ‘Entre com a altura: ‘);
% arquivo ‘area.m’
function a = area( b, h )
a = 0.5 * b * h;
% arquivo ‘saida.m’
function saida( b, h, area )
disp( ‘Base: ‘);
disp( b );
disp( ‘Altura: ‘);
disp( h );
disp( ‘Area: ‘);
disp( area );
% modulo principal – arquivo ‘teste.m’

[b,h] = entrada;
a = area( b, h );
saida(b, h, a);
Exercício 04 – Fazer uma função que receba um vetor de números reais e o

seu tamanho, e retorne o menor elemento do vetor. Inicialmente, deve-se
criar uma função para ler o vetor recebendo como argumento o número de
elementos desejados. Escrever também o módulo principal.
% arquivo ‘ler.m’
function a = ler(n)
for i = 1:n
a(i) = input( ‘A: ‘);
end
% arquivo ‘menor.m’
function m = menor(a,n)
m = a(1);
for I = 1:n
if(a(i) < m )
m = a(i);
end
end
function imprime(m)
77
disp(‘O menor valor e’);

disp(m);

x = ler(10);
y = menor(x,10);
imprime(y);
Exercício 05 – Fazer um programa seguindo as orientações abaixo:

a) Criar uma função para ler um vetor. Essa função deve receber como
argumento o número de elementos que devem ser lidos e retornar o
vetor criado;
b) Criar uma função para calcular a média dos elementos positivos de
um vetor. Essa função recebe como argumentos o vetor e o seu
tamanho, retornando o resultado da operação realizada;
c) Criar uma função para imprimir os seguintes dados: número de
elementos do vetor, o vetor correspondente e a média calculada;
d) Escrever o módulo principal considerando 10 elementos.
function v = ler(n)
for i = 1:n
v(i) = input( ‘V: ‘);
end
% arquivo ‘media.m’
function m = media(v,n)
soma = 0;
cont = 0;
for i = 1:n
if v(i) > 0
soma = soma + v(i);
cont = cont + 1;
end
end Cuidado: tratar o caso onde a
m = soma / cont; variável cont é igual a zero.
function imprime(v, n, m)
disp(n);
disp(v);
disp(m);

a = ler(10);
m = media(a,10);
imprime(a, 10, m);
Agora vamos analisar o seguinte exemplo:

78
Exercício 06
a) Fazer uma função para criar um registro e armazenar o nome e as
quatros notas de um aluno. A função deve retornar o registro criado;
b) Criar uma função que calcule a média das notas, armazenando-a no
mesmo registro. Note que a função recebe como argumento o registro;
c) Escrever o módulo principal.
function r = ler
r = { };
r.nome = input(‘Nome: ‘, ‘s’);
r.p1 = input(‘P1: ‘);
r.p2 = input(‘P2: ‘);
r.p3 = input(‘P3: ‘);
r.p4 = input(‘P4: ‘);
function media(r)
m = (r.p1 + r.p2 + r.p3 + r.p4)/4;
r.media = m;

A = ler;
media(a); Erro: o campo media foi criado dentro da função
disp(a.media); media. A variável registro precisar ser atualizada.
Exercício 07: Exemplo 06 corrigido

function r = ler
r = { };
r.p1 = input(‘P1: ‘);
r.p2 = input(‘P2: ‘);
r.p3 = input(‘P3: ‘);
r.p4 = input(‘P4: ‘);
function r = media(r)
m = (r.p1 + r.p2 + r.p3 + r.p4)/4;
r.media = m;

a = ler;
a = media(a);
disp(a.media);
79
Exercício 08: Gerenciamento Salarial

function r = ler
r = { };
r.anobase = input(‘Ano Base: ‘);
r.salmes = input(‘Salario/Mês: ‘);
r.salano = input(‘Salario/Ano: ‘);
% arquivo ‘calc0.m’: Aumento Salarial

function r = calc0(r)
r.salmes = 1.10 * r.salmes;
r.salano = 1.10 * r.salano;
% arquivo ‘calc1.m’: Salário/dia

r.saldia = r.salmes/30
% arquivo ‘calc2.m’: Salário/hora

r.salhora = r.saldia/8
% arquivo ‘calc3.m’: Classe Social

if( r.salmes > 240 )
r.classe = ‘E’;
elseif( r.salmes > 1000 )
r.classe = ‘D’;
.
.
end
% Modulo Principal
A = entrada;
A = calc0(A);
A = calc1(A);
A = calc2(A);
A = calc3(A);
imprime(A);
80
Referências Bibliográficas
CHAPMAN, S.J. (2003). Programação em MATLAB para engenheiros. São Paulo:

Thomson.
FARRER, H. et al. (1999). Programação estruturada de computadores: algoritmos
estruturados. 3.ed. Rio de Janeiro: LTC.
FEDELI, R.D.; POLLONI, E.G.F.; PERES, F.E. (2003). Introdução à ciência da
computação. São Paulo: Thomson.
GHEZZI, C.; JAZAYERI, M. (1997). Programming language concepts. 3.ed. John Wiley &
Sons.
GILAT, A. (2005). MATLAB: an introduction with applications. 2.ed. John Wiley & Sons.
GUIMARÃES, A.M.; LAGES, N.A.C. (2001). Introdução à ciência da computação. Rio de
Janeiro: LTC.
LIRA, W.W.M. (2005). Introdução à computação. CTEC-UFAL. Apostila.
MARQUES, M.A. (2005). Introdução à ciência da computação. São Paulo: LCTE.
MATSUMOTO, É.Y. (2004). MATLAB 7: fundamentos. 1.ed. São Paulo: Érica.

Apostila - Introdução A Computação PDF

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Apostila - Introdução A Computação PDF

Enviado por

Direitos autorais:

Formatos disponíveis

INTRODUÇÃO À COMPUTAÇÃO

LISTA DE FIGURAS ................................................................................................. v

Figura 1 – Stonehenge ............................................................................ 8

Tabela 1 – Linguagens de programação ...................................................20

1.2 Histórico e Desenvolvimento dos Computadores

information automatique = informação automática

Ou seja, informática é a ciência que estuda o tratamento automático e racional

Porém, a maioria dos estudiosos considera o ábaco o primeiro hardware da

O ábaco japonês é chamado de Soroban e foi trazido da china em 1622. O

Figura 3 – Régua de cálculo

Em 1642/1647, o francês Blaise Pascal conseguiu somar e subtrair utilizando sua

Em 1939 surgiu o primeiro computador eletrônico digital, o ABC (Atanasoff Berry

Além da evolução acima, pode-se destacar a evolução das telecomunicações

(internet, por exemplo) aplicados à computação, possibilitando o uso à distância de um

1.3 Sistemas de Computação

através de pulsações elétricas que, em última análise, representam os dígitos 0

Unidade de Unidade de Unidade de

Figura 4 – Arquitetura básica de um computador

A seguir, são descritos cada componente do computador digital.

1.3.1.1 Unidade de Entrada

Geralmente, a memória de alta velocidade é utilizada para armazenar

1.3.1.3 Unidade Central de Processamento (CPU)

Resumindo, o microprocessador é a unidade central de processamento (CPU) de

1.3.1.3.1 Unidade Lógica e Aritmética

1.3.1.3.2 Unidade de Controle

1.3.1.4 Unidade de Saída

2 Noções de Lógica e Algoritmos

Para compreender melhor o processo de criação de programas computacionais, é

2.1 Noções de Lógica

A Lógica de programação pode ser representada em qualquer uma das inúmeras

Existem várias formas de representar os algoritmos, como, por exemplo:

Problema: Deseja-se falar com alguém através de um telefone público. Como

Solução: Seguir os passos descritos no telefone (algoritmo)

1 – Retirar o telefone do gancho;

O algoritmo é exatamente esta seqüência de passos que foi utilizado para

Exercício 1: Algoritmo para o final de semana

1 – Ver a previsão do tempo;

Exercício 2: Algoritmo para fazer uma prova

Se souber fazer a questão

2.2.2 Refinamentos Sucessivos

1 – Remova a lâmpada queimada.

Detalhando ou refinando os passos:

1.1 – Coloque uma escada embaixo da lâmpada queimada.

2.2.3 Programa Computacional

2.3 Linguagens de Programação

Para suprir esses problemas, foram desenvolvidas linguagens em que a

Como exemplo de linguagens de programação, podemos citar o Fortran, C, C++,

Tabela 1 – Linguagens de programação

Tabela 1 – Linguagens de programação

Algumas observações podem ser feitas a respeito das linguagens apresentadas

Visual Basic, promoveram facilidades de alto nível para o rápido desenvolvimento de

2.4 Introdução ao MATLAB

resolver não só operações matemáticas complexas, mas também auxiliar na solução de

2.4.1 Execução do MATLAB

2.4.2 Alguns Comandos Básicos

Finalização dos comandos

Nota-se que o MATLAB funciona como calculadora (executa matemática

Neste exemplo, = é o comando de atribuição, e a, b, e c são variáveis. Esses

Uso do ponto e virgula

Exemplo 03: uso do ponto e vírgula

Exemplo 04: limpando a tela

Esse comando não remove as variáveis criadas. Elas continuam existindo.

Exemplo 05: como verificar quais variáveis estão sendo