Curso Matlab

Departamento de Elétrica
Prof. Rafael Cuerda Monzani
CURSO DE
MATLAB
APLICADO À
ENGENHARIA
2
1. APRESENTAÇÃO
"Codifique sempre como se o cara que for dar manutenção seja um psicopata
violento que sabe onde você mora."
Martin Golding
INTRODUÇÃO
O MatLab é um programa do tipo simulador matemático, onde é possível realizar, de maneira

simples, a inserção de dados e gerar resultados rápidos por meio de gráficos, a linguagem de
programação usada pelo MatLab é extremamente simples e de fácil acesso. O MatLab apresenta
diversos tipos de recursos matemáticos, desde a soma matricial até o cálculo de uma transformada de
Fourier, entre muitos outros elementos que podem ser analisados no MatLab. Este programa junto ao
Simulink, tornam-se ferramentas indispensáveis para modelagens e análises matemáticas presente na
vida dos cientistas.
Observação: para essa apostila fiz todos os comentários baseados no MatLab versão 2009.
TELA INICIAL DO PROGRAMA
Inicialmente será apresentada a tela do programa, descrevendo cada um de seus componentes.

A figura 1.1 demonstra os componentes da janela principal do MatLab.
WORKSPACE
CURRENT VARIÁVEIS
COMMAND WINDOW
DIRECTORY
HISTÓRICO
Figura 1.1 – Janela Inicial do MatLab
Prof. Rafael Cuerda Monzani – IFSP/SPO/DEL

3
Os componentes apresentados na figura acima serão descritos abaixo:
Command Window: esse é o principal elemento da janela do MatLab, é nesta parte onde
digitamos os comandos para a execução dos cálculos.
Current Directory: esse componente apresenta o diretório atual, será muito usado quando
trabalharmos com várias funções e chamadas de rotinas. Lembre-se de sempre setar o diretório que irá
realizar o seu trabalho, caso você não faça isso o MatLab irá sugerir a mudança de diretório para você
na execução de sua rotina.
Workspace: é o local onde as variáveis são apresentadas, em relação a nome e tamanho.
Command History: essa janela apresenta os últimos comandos que foram inseridos no
Command Window.
ATENÇÃO: caso você não esteja visualizando algum destes componentes, NÃO SE
DESESPERE, vá ao menu Desktop do MatLab e apenas clique nos componentes que queira exibir.
Bom, depois de conhecer muito bem os componentes que montam a janela, vamos ao que
interessa.

4
2. MATRIZES
"O estudo da ciência da computação não consegue transformar qualquer um

em um excelente programador, da mesma forma que o estudo de tintas e
pinceis não transforma qualquer um em um excelente pintor."
Eric S. Raymond
Primeiramente, lembre-se que para o MatLab trata todos os valores inseridos como matrizes,
independentemente do tamanho. Ou seja, um escalar é considerado uma matriz 1𝑥1, um vetor é
considerado uma matriz 1𝑥𝑛 (vetor linha) ou 𝑛𝑥1 (vetor coluna), e por fim, uma matriz é da ordem 𝑛𝑥𝑚.
INSERÇÃO DE DADOS
O programa executa as funções lançadas diretamente no Command Window, como segue no

exemplo abaixo:
cos⁡(2 ∗ 𝑝𝑖 ∗ 60)
ESCALAR
Caso você queira gravar os dados em uma variável, basta usar o sinal de =. Como segue no
exemplo abaixo:
𝑎 = 2 ∗ 𝑠𝑞𝑟𝑡(5);
Repare que no exemplo acima, foi usado o sinal de ; no final da instrução, lembrando que esse
sinal de pontuação apenas serve para que “a resposta” não seja mostrada no Command Window, o
MatLab fará internamente o processamento do cálculo. ATENÇÃO, ISSO É MUITO IMPORTANTE,
usamos o sinal de ponto e virgula para que o programa processe de forma rápida os nossos cálculos,
imagine que você irá executar uma rotina que precisa fazer cálculos matriciais de uma determinada
ordem grande e que seja executado de forma repetitiva, se o programa se preocupar em mostrar todos
os passos da iteração irá levar muito tempo, portanto, use o PONTO E VÍRGULA em TODOS os casos
dentro de uma rotina.
VETOR
Para criar um vetor no MatLab, basta usar os colchetes [⁡] associados a espaço (vetor linha), ou
ponto e vírgula (vetor coluna), como segue no exemplo abaixo:
𝑣𝑒𝑡 = [15⁡92⁡75];  vetor linha
𝑣𝑒𝑡 = [15; 92; 75];  vetor coluna
𝑣𝑒𝑡(𝑝𝑜𝑠𝑖çã𝑜) → 𝑒𝑙𝑒𝑚𝑒𝑛𝑡𝑜
𝑣𝑒𝑡(2) → 92
𝑣𝑒𝑡 = [ ]  conjunto vazio
MATRIZES

5
Basta associar a união de um vetor linha com um vetor coluna.
𝑚𝑎𝑡𝑟𝑖𝑧 = [1⁡2⁡3; 4⁡5⁡6; 7⁡8⁡9];
𝑚𝑎𝑡𝑟𝑖𝑧(𝑙𝑖𝑛ℎ𝑎, 𝑐𝑜𝑙𝑢𝑛𝑎) → 𝑒𝑙𝑒𝑚𝑒𝑛𝑡𝑜
𝑚𝑎𝑡𝑟𝑖𝑧(2,3) → 6
2 3
𝑚𝑎𝑡𝑟𝑖𝑧([1⁡2], [2⁡3]) →
5 6
𝑚𝑎𝑡𝑟𝑖𝑧(3,3) = 10;  muda o valor do elemento 3,3.
OBSERVAÇÃO: o MatLab é case sensitive, ele diferencia letras maiúsculas de minúsculas. A

variável 𝑚𝑎𝑡𝑟𝑖𝑧 é diferente da variável 𝑀𝑎𝑡𝑟𝑖𝑧 que por sua vez é diferente da variável 𝑀𝐴𝑇𝑅𝐼𝑍.
OPERADORES
Os operadores básicos para serem utilizados são:
A+B : soma
A-B : subtração
A*B : multiplicação
A/B : divisão de A por B
A\B : divisão de B por A
A^B : potência
OPERADOR “:”
Esse é O operador no MatLab e será muito usado por todos vocês para fazer inúmeras funções,
basicamente ele significa ATÉ. Exemplos gerais de uso:
Montagem de vetor: 𝑡 = 𝑣𝑎𝑙𝑜𝑟_𝑖𝑛𝑖𝑐𝑖𝑎𝑙: 𝑝𝑎𝑠𝑠𝑜: 𝑣𝑎𝑙𝑜𝑟_𝑓𝑖𝑛𝑎𝑙
Acesso de matrizes: 𝑚𝑎𝑡𝑟𝑖𝑧(1, : )  pega todos os elementos da linha 1 da matriz.
Outro exemplo para acesso de matrizes: 𝑚𝑎𝑡𝑟𝑖𝑧([1080: 𝑒𝑛𝑑], : )  pega todos os elementos de
todas as colunas da linha 1080 até o final da matriz.
OPERADOR “.”
O operador ponto (.), faz operações elemento a elemento em um vetor. Isso será muito usado
para a resolução de rotinas numéricas. O operador é colocado sempre antes do sinal de multiplicação
ou divisão, ou ainda potência. Exemplo, imagine que você possui uma impedância que varia com a
frequência e você precisa obter o valor da indutância, basta portanto dividir o vetor impedância pelo
vetor de frequência associado à 2𝜋 e retirar a parte imaginária. Veremos isso mais adiante.
OBSERVAÇÃO MUITO IMPORTANTE: os vetores precisam ser do mesmo tamanho.

6
OUTRA OBSERVAÇÃO MUITO IMPORANTE: NÃO TENHA PREGUIÇA DE LER OS

ERROS QUANDO O MATLAB DÁ, ELE É BEM CLARO NO QUE VOCÊ ESTÁ ERRANDO,
ENTÃO NÃO SE DESESPERE SE VER UMA MENSAGEM EM VERMELHO NA SUA TELA, LEIA
E IDENTIFIQUE SEU ERRO.
Mensagens comuns:
Inner matrix dimensions must agree.  as matrizes não são do mesmo tamanho
Matrix dimensions must agree.  as matrizes não são do mesmo tamanho
Undefined function or variable 'x'.  não existe um valor x, PORQUE não foi definido
Vocês já repararam que a maioria dos erros é porque as benditas das matrizes não são do mesmo
tamanho, para evitar esse problema iremos usar dois comandos para verificar o tamanho dos vetores
ou matrizes.
length(vetor): mostra o tamanho do vetor, independentemente se é coluna ou linha
size(matriz): mostra o tamanho da matriz, o primeiro número está associado ao número de

linhas da matriz e o segundo ao número de colunas. Nesse comando ainda é possível acessar o número
de linhas da matriz 𝑠𝑖𝑧𝑒(𝑚𝑎𝑡𝑟𝑖𝑧, 1) ou o número de colunas 𝑠𝑖𝑧𝑒(𝑚𝑎𝑡𝑟𝑖𝑧, 2). O número 1 está associado
a linhas e o número 2 está associado a colunas.
ACESSO DE DIRETÓRIOS (PASTAS)
Basicamente o que eu vou falar aqui NÃO é importante, porque vocês tem esses acessos direto
pela janela de Current Directory, então se quiser pular isso, fique a vontade.
Comandos usados para acesso a diretórios:
cd ou pwd: informa o diretório atual (que já está la na parte de cima do MatLab).
dir ou ls: lista o conteúdo do diretório (que já está sendo apresentado na janela do Current
Directory.
what: mostra OS ARQUIVOS do diretório, a diferença é q o dir mostra até as pastas.
which: localiza o arquivo (o que não é nada útil, a não ser que você precise do endereço dele).
!: chama um comando do sistema operacional. Ex.: !del executar.m

7
CONSTANTES PRÉ DEFINIDAS
O MatLab possui algumas constantes pré-definidas como por exemplo:
𝑝𝑖 𝜋
𝑖⁡𝑜𝑢⁡𝑗 √−1
𝑒𝑝𝑠 2.2204e-016
𝑖𝑛𝑓 Infinito
𝑛𝑎𝑛 Não é um número. Ex. 0/0
Use também notações científicas com o "𝑒". Ex.: 1𝑒3 = 1000; 1𝑒 − 3 = 0.001.
OBSERVAÇÕES:
O MatLab usa pontos e não vírgulas para a separação de casas decimais.
A função exponencial é chamada por exp⁡(𝑣𝑎𝑙𝑜𝑟).
FORMATOS
Podemos trabalhar com diferentes formatos para visualizar com a precisão necessária os nossos
resultados. Abaixo uma descrição dos formatos mais usados:
format short: padrão do Matlab, 4 casas após o ponto decimal
format long: 15 casas após o ponto decimal
format bank: formato de moeda, 2 casas após a vírgula (bom para porcentagem)
format rat: formato de fração
FUNÇÕES BÁSICAS
A seguir serão apresentadas algumas funções matemáticas básicas, dado um determinado valor
x, tem-se:
sqrt(x): calcula a raiz quadrada de x. Pode ser calculada também através de x^(1/2).
sin(x): função seno; cos(x): função cosseno; tan(x): função tangente
asin(x): arco seno; acos(x): arco cosseno; atan(x): arco tangente
OBSERVAÇÃO: lembre-se que x deve ser uma entrada em radianos nos cálculos
trigonométricos, portanto faça a conversão necessária, ou, caso queira usar em graus, use o “d” na frente
das expressões, ex.: sind(x).
Para mais detalhes sobre funções acesse help elfun. Esse comando lista as funções básicas para
diversos tipos de cálculos no MatLab, como trigonometria, exponencial, complexos e funções de
arredondamento.

8
OBSERVAÇÃO: se tem dúvida de qualquer comando, digite help comando, é a melhor forma
de aprender no MatLab, não entendeu ainda como funciona? Procure no Google um exemplo.
FUNÇÕES BÁSICAS PARA MATRIZES
As funções mais simples são:
‘: mostra a transposta de uma matriz REAL. Para matrizes complexas use o comando transp(x).
𝑑𝑒𝑡(𝐴): calcula o determinante da matriz A.
𝑖𝑛𝑣(𝐴): calcula a inversa da matriz A.
𝑟𝑎𝑛𝑑(𝑛, 𝑚): cria uma matriz randômica (aleatória) de 𝑛 linhas por 𝑚 colunas.
𝑟𝑎𝑛𝑑𝑖([𝑣𝑎𝑙𝑜𝑟_𝑖𝑛𝑖𝑐𝑖𝑎𝑙⁡𝑣𝑎𝑙𝑜𝑟⁡𝑓𝑖𝑛𝑎𝑙], 𝑛, 𝑚): é possível definir a faixa de variação para

geração de números inteiros aleatórios.
𝑒𝑦𝑒(𝑛): cria uma matriz identidade de ordem 𝑛.
𝑧𝑒𝑟𝑜𝑠(𝑛, 𝑚): cria uma matriz de zeros de ordem 𝑛𝑥𝑚.
𝑛𝑢𝑚𝑒𝑙(𝐴): retorna o número de elementos da matriz A.
𝑑𝑖𝑎𝑔(𝐴): retorna os valores da diagonal da matriz A.
𝑡𝑟𝑖𝑙(𝐴): retorna a matriz triangular inferior da matriz A.
𝑡𝑟𝑖𝑢(𝐴): retorna a matriz triangular superior da matriz A.
𝑒𝑖𝑔(𝐴): calcula os autovalores da matriz A.
sort(A): coloca os elementos da matriz em ordem crescente por coluna, para linha use sort(A,2).
Para mais funções sobre matrizes, consulte o comando ℎ𝑒𝑙𝑝⁡𝑒𝑙𝑚𝑎𝑡.
TEXTO
A inserção de texto se dá pelo uso de apóstrofes. Ex.: ‘oi‘. O texto se comporta como uma matriz,
portanto é possível aplicar a transposta, fazer concatenações, substituições de elementos e assim por
diante.
COMANDO CELL
Permite armazenar diferentes tipos de dados (matrizes, textos, escalares, vetores, ...) em um
único nome. Ex.: 𝑐𝑒𝑙𝑢𝑙𝑎⁡ = ⁡ {𝑒𝑦𝑒(3)⁡⁡‘𝑡𝑒𝑥𝑡𝑜’⁡; ⁡𝑝𝑖⁡⁡[0: 1𝑒 − 3: 5]};
Repare que nesse caso para a criação de células, usam-se chaves.
3. PROGRAMAÇÃO

9
"A programação hoje em dia é uma corrida entre engenheiros de software

tentando fazer programas maiores e melhores a prova de idiotas e o universo
tentando fazer idiotas maiores e melhores. Até agora o universo está ganhando."
Rick Cook
Irei explicar nesse capítulo quais são os comandos básicos de programação em qualquer
linguagem, isso é, estruturas de decisão (if … else), estruturas de repetição (for, while). Se você já
conhece isso, parabéns você tem noção de programação, portanto, pule esse capítulo.
Todos os programas, rotinas, procedimentos, ou o nome que você quiser dar pro seu código
serão escritos na janela do script, para que posteriormente esse código possa ser editado. Para isso vá
ao menu File->New->Blank M-file, ou clique no botão novo ( ). O arquivo chama-se M-file porque
a extensão dele será .m. Você deverá ter uma tela parecida com essa.
Figura 3.1 – Janela do Editor do M-file (script)
Muito bem, caso esteja nessa tela podemos continuar.
Nessa janela algumas palavras aparecerão com cores diferentes, vamos entende-las.
Palavras reservadas (for, end, if): azul
Comentários: verde
Cacteres em edição: púrpura
Comandos do sistema operacional: pardo
Erro: vermelho

10
Funções e variáveis: preto
ESTRUTURA DE DECISÃO
A estrutura de decisão está relacionada a análise de uma condição, se essa condição for
verdadeira ela executa uma resposta, caso seja necessário, se for falsa executa outra resposta.
Por exemplo, deseja-se verificar se a pessoa pode acessar determinado conteúdo.
idade=15;
se idade<18
‘acesso negado’
caso contrário
‘acesso permitido’
Fim
Toda estrutura no MatLab deve apresentar um fim, representado pelo comando end.
Substituindo os dados apresentados pelos comandos em MatLab teremos:
idade=15;
if idade<18
‘acesso negado’
else
‘acesso permitido’
End
Simples e fácil, basta na hora de montar seu programa pensar na lógica do que você deseja
visualizar na resposta. Segue abaixo código de mais um exemplo, que verifica se o número é par ou
ímpar.
numero = 28;
if mod(numero,2)==0
‘O número é par’
else
‘O número é ímpar’
End
Operadores Lógicos
== Igual
~= Diferente
< Menor
> Maior
<= Menor ou igual
>= Maior ou igual
~ Not
& E (and)
| Ou (or)
SWITCH

11
Esse comando analisa várias respostas para uma mesma variável.
switch valor_teste
case 10
tipo =’Numero 10’;
case 100,200,300
tipo = ‘Numero 100, 200 ou 300’;
case ‘Alfa’
tipo = ‘Texto Alfa’
case {‘Beta’, ‘Gama’, ‘Delta’}
tipo = ‘Texto Beta, Gama ou Delta’;
otherwise
tipo = ‘valor_teste não reconhecido’;
end
ESTRUTURAS DE REPETIÇÃO
As estruturas de repetição servem para fazer cálculos repetitivos. Os comandos usados são for
quando se conhece o número de iterações que se deseja realizar ou while quando se conhece apenas o
critério de parada. Inicialmente será apresentado o comando for.
for i=<valor_inicial>:<incremento>:<valor final>

Exp. 1;
Exp. n;
End
Vamos fazer o seguinte exemplo: ∑10

𝑖=1 2𝑖.
aux = 0;
for i=1:10
aux=aux+2*i;
end
Pode-se gerar matrizes a partir do uso de dois comandos for. Ex.:
for i=1:3
for j=1:3
matriz(i,j)=2*i+j^3;
end
end
Com esse exemplo, teremos a seguinte matriz:
3 10 29
𝑚𝑎𝑡𝑟𝑖𝑧 = ⁡ 5 12 31
7 14 33

12
Outro exemplo para a geração do triângulo de pascal
n=5;
a=eye(n);
a(:,1)=1;
for i=3:n
for j=2:i
a(i,j)=a(i-1,j-1)+a(i-1,j);
end
end
Agora trabalharemos com o comando while, lembre-se que esse comando executará o laço até
o momento em que sua condição for satisfeita.
while <condição>
Exp. 1;
Exp. n;
End
Vamos verificar qual é o primeiro múltiplo de 27 a partir do número 542:
num=542;
div=27;
while mod(num,div)~=0
num=num+1;
end
num %colocar essa variável nessa posição mostra o valor dela, repare que
%está sem o ;
Muito bem, essa foi a parte básica dos comandos de programação.
Pratique bastante, com diversos exercícios.
Lembre-se você não vai aprender a programar se não praticar!!!

13
4. PROGRAMANDO NO M-FILE
“Um computador permite que você faça mais erros mais

rapidamente do que qualquer outra invenção da história da
humanidade, com exceção das mãos e da tequila.”
Mitch Ratcliffe
Nesse capítulo trataremos da inserção de códigos no M-file, os scripts desenvolvidos nesse

capítulo serão chamadas de ROTINAS (pode-se chamar também de procedures, procedimentos).
Preste bem atenção, uma ROTINA é diferente de uma FUNÇÃO (capítulo 6). A rotina não necessita de
parâmetros de entrada, essa, executa um programa sem retornar nenhum valor.
OBSERVAÇÃO IMPORTANTE: para executar as rotinas, você deve sempre salvá-las, o nome
da rotina não deve conter espaços, caracteres especiais ou começar com números.
Iremos criar algumas rotinas nesse capítulo, mas antes, quero deixar claro aqui o que se tornará
obrigatório no início de todas as rotinas que não são dependentes de outras. Todas as rotinas deverão
conter em seu cabeçalho os seguintes comandos:
clc: clear command window, limpa a tela de trabalho
clear all: limpa todas as variáveis do workspace
close all: fecha todas as janelas gráficas abertas.
Todos os programas deverão conter comentários sobre o que você está fazendo, ou porque criou
determinada variável, lembre-se que não será só você que irá usar seu programa, e mesmo que for, vá
por mim, você não lembrará o que você fez no mês passado se não deixar um recado anotado. Portanto
todo o código deverá ser comentado, para isso use o símbolo de porcentagem (%), seguido do
comentário a ser feito.
A primeira rotina a ser trabalhada será a determinação da convergência de uma série. Dada a
série abaixo, determine se ela é convergente ou não.
∞
1
𝑓(𝑥) = ∑
𝑛!
𝑛=1
Solução:
clc
clear all
close all
%número de elementos que eu quero para ver se a função converge ou não

n=10;
%criando uma variável para inicializar o somatório
aux=0;
for i=1:n
f(i)=aux+1/factorial(i);
aux=f(i);
end
plot(f)

14
A seguir teremos outro exemplo considerando a aplicação de um vetor, sabe-se que 𝑓(𝑥) existe
no intervalor −2 < 𝑥 < 2.
∞
4 (−1)𝑛+1 nπx
𝑓(𝑥) = ∑ sen ( )
𝜋 𝑛 2
𝑛=0
Solução:
clc
clear all
close all
%define a variação de x
x=-2:1e-2:2;
%número de elementos que eu quero para ver se a função converge ou não
n=10;
%criando uma variável para inicializar o somatório
f=0;
for i=1:n
f=f+4/pi*(-1)^(i+1)/i.*sin(i*pi*x/2);
end
plot(x,f)
Vamos analisar o seguinte código e verificar o que ele faz.
i=rand(1,10);
v=rand(1,10);
r1=v./i;
for j=1:10
r2(j)=v(j)/i(j);
end
r1>r2
Comandos usados em rotinas:
disp(‘texto’): mostra o texto na tela;
i = input(‘Entre com o número de elementos : ‘)  o usuário entra com um valor no Command

Window para a variável i.

15
5. DEBUG
“Se depurar é o processo de remoção de bugs do software, então

programação deve ser o processo de colocação deles.”
Edsger Dijkstra
Para depurar (debugar) um código iremos usar as seguintes ferramentas do MatLab:
: Executar a rotina ou simplesmente F5.
: colocar um breakpoint (ponto de parada) na rotina, essa ação pode ser feito clicando na
parte cinza do script antes da linha de comando, uma bola cinza aparecerá indicando que um ponto de
parada (breakpoint) foi colocado, quando o código for executado, o cursor parará nesse ponto e a bola
ficará vermelha.
: remove todos os breakpoints do arquivo.
Os botões abaixo só ficarão ativos, caso exista breakpoints.
: esse botão executa a próxima linha do programa.
: caso você esteja chamando uma rotina ou função dentro da rotina que está sendo executada,
esse botão entra no arquivo que está sendo chamado.
: esse botão executa o programa até o próximo breakpoint, ou, caso não exista outro, executa
o programa até o final.
: esse botão cancela a execução da rotina
OBSERVAÇÃO: caso sua rotina tenha entrado em um loop infinito, você pode “quebrar” a
execução da rotina na janela do Command Window através do comando CTRL C.
Outra observação: no momento da execução, quando o ponteiro do mouse é colocado sobre

qualquer variável, o mesmo mostrará o conteúdo dela, caso não mostre você pode ir ao Command
Window e digitar o que deseja visualizar, assim você saberá se a variável está armazenando o valor
esperado ou não, possibilitando a identificação de erros.
Outras informações relevantes:
CTRL A: seleciona todo o código
CTRL I: faz o identamento de todo o código
CTRL R: transforma um código em comentário
CTRL T: transforma um comentário em código

16
6. TRABALHANDO COM ARQUIVOS
"A arte de programar consiste em organizar e dominar a complexidade."

Edsger W. Dijkstra
Os comandos para se trabalhar com arquivos são aqueles usados para carregar dados e salvar
esses dados em scripts, por exemplo, dado o código abaixo:
for j = 1:3,
for k = j:3
str = ['Zext' int2str(j) '_' int2str(k) '.m'];
fid(j,k) = fopen(str,'w');
if j==k
str = ['%% Imp. externa da fase ' int2str(j) ' \n clear x\n x = [\n'];
fprintf(fid(j,k),str);
else
str = ['%% Ze entre ' int2str(j) ' e ' int2str(k) ' \n clear x\n x = [\n'];
fprintf(fid(j,k),str);
end
end
end
No código acima, a variável str armazena o nome do arquivo, a função int2str converte um
número inteiro em texto (string), repare na extensão ‘.m’ no final do arquivo.
A matriz fid abre todos os arquivos a partir do comando fopen no modo de escrita ‘w’ (write). O
comando fprintf(fid(j,k),str) armazena em cada um dos arquivos o texto colocado dentro da variável do
tipo string str.
𝑓𝑜𝑝𝑒𝑛(𝐴𝑟𝑞𝑢𝑖𝑣𝑜, 𝐴𝑐𝑒𝑠𝑠𝑜): esse comando abre um arquivo, e acessa ele por:
′𝑟′: apenas para leitura
′𝑤′: para gravação (cria o arquivo se necessário).
Continuando o código, após realizar todos os procedimentos de cálculos, os dados são

armazenados da seguinte forma.
for j = 1:length(freq),
for k = 1:3
for m = k:3
z = i*2*pi*freq(j)*indut(k,m);
fprintf(fid(k,m), '%30.20f %30.20f\n',real(z),imag(z));
end
end
end
for j = 1:3
for k = j:3
fprintf(fid(j,k), ']; \n');
str = ['ze' int2str(j) '_' int2str(k) ' = x(:,1) + i*x(:,2);'];
fprintf(fid(j,k), str);
end
end
fclose('all');

17
No primeiro laço for observa-se que os valores de impedância são calculados para todos os
valores de frequência, e armazenados em cada um dos arquivos fid correspondente, repare que nesse
caso o comando fprintf trabalha da seguinte forma, primeiro é informado o arquivo onde será escrito os
valores, depois é informado o tipo de valor a ser inserido, como os cálculos retornam valores de ponto
flutuante (números com vírgula) é usado o recurso %f. Para que os dados sejam apresentados de forma
espaçada, coloca-se os valores %30.20f, onde terá um espaço de 30 caracteres para a parte inteira e 20
para a parte decimal (apenas para efeito visual da apresentação dos resultados). como foram inseridos
dois valores de %f, informa-se no final quais serão as variáveis que ocuparão esses espaços separadas
por vírgula.
Os tipos de dados que podem ser armazenados são:
%c Caractere
%s String (cadeia de caracteres)
%d Decimal
%f Ponto flutuante
%e Exponencial
%x Hexa minúsculo
%X Hexa maiúsculo
%o Octal
Caracteres que podem ser utilizados nos formatos:
\b Backspace
\n Pula linha
\r Retorno de linha
\t Tab horizontal
\\ Barra invertida \
\” Aspas duplas
%% Porcentagem %
Por fim, o último laço escreve um ] no final do arquivo, define um nome para a função, e a
última linha fecha todos os arquivos abertos fclose(‘all’);.
Esses arquivos são chamados de scripts, pois não executam função alguma, apenas armazenam
os valores para serem usados por outras rotinas.
Existem inúmeras outras funções para leitura/escrita em arquivos. Essa apostila restringe-se
apenas a esse exemplo básico.
Outros comandos são:
𝑠𝑝𝑟𝑖𝑛𝑡𝑓: grava dados em uma string.
𝐴 = 𝑠𝑝𝑟𝑖𝑛𝑡𝑓(′𝑅𝑒𝑠𝑢𝑙𝑡𝑎𝑑𝑜: %𝑓 ′ , 𝑣𝑎𝑙𝑜𝑟)
𝑠𝑠𝑐𝑎𝑛𝑓: lê dados armazenados em uma string.
𝐵 = 𝑠𝑠𝑐𝑎𝑛𝑓(𝑠𝑡𝑟𝑖𝑛𝑔, 𝑓𝑜𝑟𝑚𝑎𝑡𝑜)

18
7. TRABALHANDO COM SÍMBOLOS
“Eu sempre quis que o meu computador fosse tão fácil de

usar como o meu telefone, o meu desejo foi realizado, pois
eu já não consigo descobrir como usar o meu telefone.”
Bjarne Stroustrup
Além de cálculo numérico, o MatLab também permite efetuar cálculo simbólico. Para esse
efeito, existe uma toolbox de matemática simbólica (“Symbolic Math Toolbox”).
Com esta toolbox podem-se efetuar cálculos de diferentes naturezas, designadamente: cálculo
propriamente dito (diferenciação, integração, determinação de limites, somatórios, série de Taylor, etc.);
álgebra linear (inversa de uma matriz, determinantes, valores próprios, etc.); simplificação de
expressões algébricas; obtenção de soluções analíticas de equações algébricas e diferenciais;
Transformadas de Laplace, Z e de Fourier, etc.
Para indicar ao MatLab que uma dada variável (ou expressão) deve ser encarada como objeto
simbólico usa-se o comando 𝑠𝑦𝑚.
Observe as diferenças entre os dois exemplos a seguir apresentados:
>> a=sqrt(2)
a =
1.4142
>> b=sqrt(sym(2))
b =
2^(1/2)
Neste último caso, foi indicado ao MatLab que ele devia considerar o número 2 como uma
constante simbólica pelo que ele devolve o resultado sem efetuar qualquer cálculo numérico (b será
encarado em todos os cálculos posteriores como uma constante simbólica). Caso seja necessário, pode-
se a qualquer momento converter b para o valor numérico correspondente:
>> double(b)
ans =
1.4142
Outro exemplo ilustrativo das diferenças entre cálculo numérico e simbólico:
>> sym(2)/sym(3)+sym(1)/sym(5)
ans =
13/15
>> 2/3+1/5
ans =
0.8667

19
𝑠𝑖𝑚𝑝𝑙𝑖𝑓𝑦: simplifica expressões. Ex.:
>> a=sym('x^2-1'), b=sym('x-1')

a =
x^2-1
b =
x-1
>> simplify(a/b)
ans =
x+1
Frequentemente, temos necessidade de dizer ao MatLab que diversas variáveis devem ser
consideradas como simbólicas. Nesse caso, torna-se mais fácil e prático usar o comando 𝑠𝑦𝑚𝑠 em vez
de 𝑠𝑦𝑚. Como exemplo, vamos assumir que se pretende estudar a função quadrática f, dada pela
expressão 𝑎 ∗ 𝑥^2 + 𝑏 ∗ 𝑥 + 𝑐. Neste caso, devemos em primeiro lugar indicar ao MatLab que a, b, c e x
devem ser tratadas como variáveis simbólicas e só depois definir a função f:
>> syms a b c x
>> f=sym('a*x^2+b*x+c') % em alternativa pode-se fazer f=a*x^2+b*x+c
f =
a*x^2+b*x+c
Pode-se agora manipular f da forma desejada, tendo a garantia que o MatLab vai tratar todas
as variáveis como simbólicas.
SUBSTITUINDO VALORES
Uma vez definida f, pode-se agora criar uma nova função em que a sua expressão designatória
é igual à da função f após substituirmos a, b e c por 4, 5 e 8, respectivamente. Essa operação poderá ser
efetuada usando o comando subs:
>> g=subs(f,[a,b,c],[4,5,8])
g =
4*x^2+5*x+8
ENCONTRANDO A VARIÁVEL
O comando 𝑓𝑖𝑛𝑑𝑠𝑦𝑚 permite ver quais as variáveis simbólicas presentes numa dada expressão.
Por exemplo, em f existem 4 variáveis simbólicas mas em g existe apenas uma (x):
>> findsym(g)
ans =
x

20
RESOLVENDO EQUAÇÕES
O comando 𝑠𝑜𝑙𝑣𝑒 é bastante útil, pois permite resolver equações (ou sistemas de equações)
algébricas. Como exemplo, pretende-se achar as soluções da equação 𝑥^2 − 10 ∗ 𝑥 + 21 = 0. Pode-se
então fazer:
>> solve('x^2-10*x+21')
ans =
73
Mais exemplos demonstrativos do uso da função solve:
>> equacaosegundograu='a*x^2+b*x+c=0‘;
>> solve(equacaosegundograu)
ans =
1/2/a*(-b+(b^2-4*a*c)^(1/2))
1/2/a*(-b-(b^2-4*a*c)^(1/2))
>> B=solve(equacaosegundograu,'a=1','b=-3','x=10') % calcula o valor de c que
%fará com que a condição seja verdadeira
B =
a: [1x1 sym]
b: [1x1 sym]
c: [1x1 sym]
x: [1x1 sym]
>> B.c % vê qual o valor de c armazenado na estrutura B
ans =
-70
Mais um exemplo do uso do comando solve:
>> S = solve('x^2 + x*y + y = 3','x^2 - 4*x + 3 = 0')

S =
x: [2x1 sym]
y: [2x1 sym]
>> S.x
ans =
1
3
>> S.y
ans =
1
-3/2
Neste último exemplo, o resultado do sistema de equações é armazenado numa estrutura, a

qual contém as duas soluções para x e y.
Podemos ver alguns dos resultados anteriores com um aspecto mais amigável usando o
comando pretty. Um exemplo:
>> h=solve(equacaosegundograu);
>> pretty(h)

21
DERIVADA
A toolbox de matemática simbólica disponibiliza um conjunto de funções de cálculo, entre as

quais se destacam a derivação, a qual pode ser efetuada usando o comando diff:
>> f=sym('3*x^3+4*x^2-5');
>> diff(f)
ans =
9*x^2+8*x
% ===== Código alternativo =========
>> syms x
>> f=3*x^3+4*x^2-5
f =
3*x^3+4*x^2-5
>> diff(f)
ans =
9*x^2+8*x
INTEGRAL
Para calcular integrais indefinidos pode-se usar o comando int.
>> syms a b c x
>> h=a*x^2+b*x+c;
>> int(h,b) % calcula a primitiva de h considerando que b é a variável independente
ans =
a*x^2*b+1/2*b^2*x+c*b
Ainda outro exemplo, agora com integrais definidos:
>> f=sym(sin(x))
f =
sin(x)
>> int(f,0,pi)
ans =
2
SÉRIE DE TAYLOR
Pode-se ainda decompor uma dada função em série de Taylor (ou Maclaurin), usando o
comando taylor. Alguns exemplos:
>> syms x
>> g=exp(x*sin(x))
g =
exp(x*sin(x))
>> t=taylor(g,12,2); % decompõe g em série de Taylor, obtendo os 12 primeiros termos não
% nulos, em torno do ponto x=2.
>> syms x
>> f=1/(5+4*cos(x));
>> M=taylor(f,8) % obtém os termos da série de Maclaurin até (mas não incluindo) o de ordem
8
M =
1/9+2/81*x^2+5/1458*x^4+49/131220*x^6

22
EQUAÇÕES DIFERENCIAIS
Para resolver equações diferenciais de qualquer ordem, usa-se o comando 𝑑𝑠𝑜𝑙𝑣𝑒. Alguns
exemplos:
>> dsolve('Dy=1+y^2') % calcula a solução da equação y’=1+y^2

ans =
tan(t+C1) % C1 é uma constante
>> y=dsolve('Dy=1+y^2','y(0)=1') % resolve a equação com uma condição inicial
y =
tan(t+1/4*pi)
Nos exemplos anteriores, a letra ‘D’ indica ao MatLab que se trata da primeira derivada (por
padrão a variável independente é t). Colocando um número inteiro após D dá indicação ao MatLab de
uma derivada de ordem superior. Como exemplo, vamos admitir que se pretende resolver a equação
diferencial d(3)y/dx3=y, com as condições iniciais y(0)=1; y’(0)=-1; y’’(0)=pi. A solução desta equação
pode ser obtida da seguinte forma:
>> y=dsolve('D3y=y','y(0)=1','Dy(0)=-1','D2y(0)=pi','x')
y =
1/3*pi*exp(x)-1/3*(1+pi)*3^(1/2)*exp(-1/2*x)*sin(1/2*3^(1/2)*x)+(-
1/3*pi+1)*exp(-1/2*x)*cos(1/2*3^(1/2)*x)
FATORAÇÃO
Neste contexto, dois comandos muito úteis são 𝑒𝑥𝑝𝑎𝑛𝑑 e 𝑓𝑎𝑐𝑡𝑜𝑟. Alguns exemplos da sua
utilidade:
>> syms x
>> f=(x-3)^3+(x+1)^2-3
f =
(x-3)^3+(x+1)^2-3
>> expand(f)
ans =
x^3-8*x^2+29*x-29
>> factor(x^3+x^2-21*x-45)
ans =
(x-5)*(x+3)^2
Consulte o help e veja ainda a utilidade de simple, collect e combine.
Para mais informações a respeito do uso da toolbox, digite no Command Window:
symintro : Introdução
symcalcdemo : Cálculo
symlindemo : Álgebra linear
symeqndemo : Solução de equações

23
8. TRABALHANDO COM FUNÇÕES
“Os primeiros 90% do código representam os primeiros 10% do

tempo de desenvolvimento. Os 10% restantes do código é para
mostrar aos outros os 90% do tempo de desenvolvimento."
Tom Cargill
Nesse capítulo trabalharemos com a criação de funções usando os recursos aprendidos nos
capítulos anteriores.
OBSERVAÇÃO IMPORTANTE: ao criar uma função, o nome do arquivo deverá ter o mesmo
nome da função.
Uma função nada mais é do que uma rotina com a entrada de parâmetros e retorno de uma
resposta. Por exemplo, vamos fazer a função média, como segue no exemplo abaixo:
media.m
function m = media(n)
soma=0;
for i=1:length(n)
soma=n(i)+soma;
end
m=soma/length(n);
No capítulo anterior, trabalhamos com a toolbox de símbolos do MatLab, outra maneira de se

trabalhar com funções, é usando as mesmas como strings e convertendo elas em funções. A seguir,
iremos trabalhar com comandos para a inserção de funções por meio de strings.
O exemplo que será usado é o método da seção áurea para a definição do ponto de mínimo de
uma função, dado seu intervalo. O objetivo desse exemplo não é a explicação do método e sim a
explicação das funções do MatLab que estarão sendo usadas. A descrição das funções será feita abaixo.
Repare que em uma função, não se trabalha com o comandos de limpar as variáveis como na
inicialização de uma rotina, (clear all). Salve esse arquivo com o nome de aurea.m.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Método da Seção Aurea %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%aurea(fun, intervalo, l)
%fun = função (colocar entre aspas simples e em termos de x)
%intervalo = [a b], onde a é o início e b é o final do intervalo
%l é o intervalo máximo de tolerância permitido
function f = aurea(fun, intervalo, l, metodo)
%Fecha tudo
close all;

24
%Intervalo
ak = intervalo(1);
bk = intervalo(2);
int = bk-ak;
%Verificação de erros
if bk <= ak
disp('Erro: b deve ser maior do que a')
end
if(l <= 0)
disp('Erro: l deve ser positivo')
end
%Convertendo em função em termos de x

f = inline(fun);
%Fator de convergencia
alpha = 0.618;
%Valores de lambda e mi
lambda = ak+(1-alpha)*int;
mi = ak + alpha*int;
fprintf(' k ak bk lamda_k mu_k

theta_lamda_k theta_mu_k\n')
fprintf('|---------|----------|----------|---------|---------|-----------
---|----------|\n')
%Contador k
k=1;
while int>=l
%Encontra o valor de f(lambda) | A função subs, substitui a funça f,
em
%termos de x pelo valor desejado
f_lambda = feval(f,lambda);
f_mi = feval(f,mi);
fprintf('%7.0f %10.3f %10.3f %10.3f %10.3f %10.3f %12.3f \n',k,ak,bk,

lambda,mi,f_lambda,f_mi)
%Caso f(lambda)>f(mi)
if f_lambda>f_mi
ak=lambda;
lambda=mi;
int=bk-ak;
mi=ak+alpha*int;
else
bk=mi;
mi=lambda;
int=bk-ak;
lambda=ak+(1-alpha)*int;
end
k=k+1;
end
fprintf('\n O ponto mínimo está no intervalo [%f, %f] \n',ak,bk);

f = lambda;

25
A função recebe 3 parâmetros de entrada, como descreve os comentários, 𝑓𝑢𝑛 é a função de

entrada, 𝑖𝑛𝑡𝑒𝑟𝑣𝑎𝑙𝑜 é o intervalo de análise do ponto de mínimo da função, 𝑙 é o erro máximo permitido
para a definição do ponto de mínimo.
O comando 𝑖𝑛𝑙𝑖𝑛𝑒 converte uma string (texto) em uma função que poderá ser analisada pelo
MatLab, essa função poderá ser derivada, integrada, entre outros procedimentos que podem ser
executados com análise de funções.
Como já visto o comando 𝑓𝑝𝑟𝑖𝑛𝑡𝑓 imprime, nesse caso, na tela os dados mostrados entre aspas
simples, apenas para que o usuário verifique as iterações que o programa executa.
Verifique no laço 𝑤ℎ𝑖𝑙𝑒 o programa será executado até o momento em que o intervalo for maior
que o valor definido para o erro na diferença do intervalo.
O comando 𝑓𝑒𝑣𝑎𝑙 é responsável por resolver a função para determinado valor, como mostrado
no código acima, deve-se definir qual é a função e qual o valor que a mesma receberá para que ele faça
as devidas substituições.
A estrutura de decisão serve para analisar qual será o valor que deverá ser alterado. Todos as
iterações serão apresentadas ao usuário por causa do comando 𝑓𝑝𝑟𝑖𝑛𝑡𝑓.
Por fim, o programa também terá armazenado o intervalo onde se encontra o ponto de mínimo,
e esse valor será mostrado na tela com o uso da ferramenta 𝑓𝑝𝑟𝑖𝑛𝑡𝑓.
Como exercício, sugere-se que você pratique buscando outras modelagens para a definição do
ponto de mínimo de uma função, como, por exemplo, o método da bisseção ou método de Newton.
Colocarei mais um exemplo para que se entenda como usar os procedimentos de função
considerando mais de uma variável. O método apresentado a seguir, é baseado no Método de Newton
Modificado.
O código abaixo será analisado na sala de aula.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Método de Newton %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%fun é a função (deve ser escrita entre aspas simples
%xi é o valor inicial para x, [x1;x2]
%l é o intervalo de tolerância máximo permitido
function f = newton_modificado(fun,xi,l)
%Limpa a tela
clc;
%Fecha tudo
close all;
%Numero máximo de iterações permitida

kmax = 1e3;
%Defininco valor inicial de x

xk = xi;
%Definição da função

26
f = inline(fun);
f_x = feval(f, xk(1), xk(2));
%Gradiente
G = [diff(fun,'x1');diff(fun,'x2')];
G = inline(G);
G_x = feval(G, xk(1), xk(2));
%norma do gradiente
norma_G = norm(G_x);
%Hessiana
f11 = diff(fun,'x1',2);
f12 = diff(diff(fun,'x1'),'x2');
f21 = diff(diff(fun,'x2'),'x1');
f22 = diff(fun,'x2',2);
H = [f11 f12;f21 f22];

H = inline(H);
H_x = feval(H, xk(1));
dk = -(G_x/norma_G);
disp('Informe o método desejado para resolução')

disp('1)Seção Áurea')
disp('2)Bisseção')
disp('3)Newton')
metodo = input('');
fprintf('\n k x1 x2 alphak ||G(xk)|| \n')

fprintf('|--------|---------|----------|----------|------------|\n')
disp('MÉTODO DO GRADIENTE')
%Intervalo inicial e final

ak = 0;
bk = 1;
%Tolerancia para determinar alphak

e = 1e-3;
k = 1;
while (norma_G > l && k~=4)
syms alphak
f_x = feval(f, xk(1)+alphak.*dk(1), xk(2)+alphak.*dk(2));
if metodo==1
alpha_k = aurea(f_x,[ak bk],e,0);
end
if metodo==2
alpha_k = bissecao(f_x,[ak bk],e,0);
end
if metodo==3

27
alpha_k = newton(f_x,1,e,0);
end
fprintf('%7.0f %10.4f %10.4f %10.4f %11.5f \n',k, xk(1), xk(2),

alpha_k, norma_G)
%Atualiza xk
xk = xk + alpha_k*dk;
%Gradiente
%norma
dk = -(G_x/norma_G);
if k==kmax
break
end
k = k+1;
end
fprintf('\n')
disp('MÉTODO DE NEWTON')
k = k-1;
while norma_G > l
k = k+1;
fprintf('\n %7.0f %10.4f %10.4f %10.4f %11.5f \n',k, xk(1), xk(2),

norma_G)
%Função
f_x = feval(f, xk(1), xk(2));
%Gradiente
%norma do gradiente
%Hessiana
H_x = feval(H,xk(1));
inv_H = inv(H_x);
F = -inv_H*G_x;
xk = xk + F;
end

28
9. GRÁFICOS
"Se um engenheiro não resolve, chame um padre..."
Chegamos ao capítulo de gráficos, esse capítulo tratará com muitos detalhes o gerenciamento
de gráficos, portanto, se ficar um pouco extenso, deixo a você a continuação da leitura dele em casa.
O primeiro comando para a criação de um gráfico é o 𝑝𝑙𝑜𝑡, esse é o mais simples de todos e
provavelmente todos já estão acostumados a trabalhar com ele.
Você pode plotar tanto uma função com o comando 𝑝𝑙𝑜𝑡(𝑓) ou pode definir a variação no eixo
𝑥 para essa função 𝑝𝑙𝑜𝑡(𝑥, 𝑓).
Outra forma de se trabalhar com o recurso de gráficos, é plotar várias funções em um mesmo
gráfico, isso pode ser feito de algumas formas. A mais simples é colocar tudo na mesma linha, como
segue no exemplo abaixo:
𝑝𝑙𝑜𝑡(𝑥, 𝑓1, 𝑥, 𝑓2, 𝑥, 𝑓3, … , 𝑥, 𝑓𝑛)
Outra forma de colocar todas essas funções no mesmo gráfico, é criar um vetor e armazenar
todas as funções, como no exemplo abaixo:
𝑓𝑢𝑛𝑐𝑎𝑜 = [𝑓1⁡𝑓2⁡𝑓3 … 𝑓𝑛]
𝑝𝑙𝑜𝑡(𝑥, 𝑓𝑢𝑛𝑐𝑎𝑜)
Outra forma ainda de se plotar várias funções em um mesmo gráfico é usar o comando ℎ𝑜𝑙𝑑,
como segue no exemplo abaixo.
𝑝𝑙𝑜𝑡(𝑥, 𝑓1)
ℎ𝑜𝑙𝑑
𝑝𝑙𝑜𝑡(𝑥, 𝑓2)
A mudança dos atributos (cor, espessura, tipo da linha) também pode ser realizadas por meio
do comando 𝑝𝑙𝑜𝑡.
𝑝𝑙𝑜𝑡(𝑥, 𝑦, 𝑠)
Onde 𝑠 é uma string que pode receber os seguintes valores

29
O uso desses recursos permite automatizar a produção de um gráfico por meio de um código.
Outros recursos que também podem ser usados são:
𝑡𝑖𝑡𝑙𝑒(′𝑡𝑒𝑥𝑡𝑜′ ): define o título do gráfico
𝑥𝑙𝑎𝑏𝑒𝑙(′𝑡𝑒𝑥𝑡𝑜′ ): define o rótulo do eixo x
𝑦𝑙𝑎𝑏𝑒𝑙(′𝑡𝑒𝑥𝑡𝑜′ ): define o rótulo do eixo y
Caso você queira colocar dois gráficos na mesma janela ocupando telas diferentes, pode-se usar
o comando 𝑠𝑢𝑏𝑝𝑙𝑜𝑡. Ele funciona como uma matriz, onde define-se o tamanho 𝑛𝑥𝑚 e a posição que
deseja-se colocar. Exemplo:
subplot(2,1,1)
subplot(212)
Repare que no exemplo anterior, tanto faz, o uso ou não de vírgulas.
Todos os comandos podem ser alterados também de forma simples, usando o recurso de
𝑝𝑙𝑜𝑡𝑡𝑜𝑜𝑙𝑠. Esse recurso é acessado na janela do gráfico no último botão da caixa de ferramentas ( ).
Observe o gráfico da figura abaixo.
60
0pr1/0
50 0pr1/pr1
DIFERENÇA RELATIVA (%)
40
30
20
10
0
1 2 3 4 5 6 7 8
10 10 10 10 10 10 10 10
FREQUÊNCIA [Hz]
Esse recurso permite definir o uso do título e dos rótulos, para isso clique no gráfico (na parte
branca), e observe as propriedades que aparecem abaixo:
Tem-se as opções:
Title (que define o título);

30
Axis está relacionado com eixo, portanto, tem-se X Axis, Y Axis e Z Axis, basicamente define-se
o rótulo do eixo na propriedade Label, pode-se definir também o intervalo do eixo, caso queira voltar
ao normal, pode deixar marcada a propriedade Auto.
A escala dos eixos pode ser linear ou logarítmica, caso você queira plotar um gráfico direto na
escala logarítmica, deverá usar as seguintes funções:
𝑠𝑒𝑚𝑖𝑙𝑜𝑔𝑥(𝑥, 𝑓): log no eixo x
𝑠𝑒𝑚𝑖𝑙𝑜𝑔𝑦(𝑥, 𝑓): log no eixo y
𝑙𝑜𝑔𝑙𝑜𝑔(𝑥, 𝑓): log no eixo x e no eixo y
Ao definir-se o eixo dos títulos você poderá alterar a fonte, selecione o texto desejado e altere a
fonte, tamanho e estilo (negrito, itálico).
OBSERVAÇÃO: Caso a barra de propriedades não esteja aparecendo você poderá consultar o
menu View.
Ainda na barra de propriedades, é possível alterar as propriedades da curva que aparece no

gráfico, como, por exemplo, cor, espessura, tipo da linha com marcadores, entre outros recursos.
O painel Figure Palette permite que o usuário defina comandos de 𝑠𝑢𝑏𝑝𝑙𝑜𝑡, verifique quais as
variáveis presentes no gráfico e também use recursos gráficos para inserir no texto.
Basicamente, nesse painel, a opção interessante é o Text Box, escolha essa opção, clique na tela
na posição desejada, digite o texto desejado. Caso você queira colocar um texto do alfabeto grego, use o
comando com “\”. Ex.: \alpha, \beta, \epsilon, …. Basicamente, use a formatação LaTex, ou seja, para
sobrescrito use (^), subscrito (_). Esse texto, também possui propriedades de fonte, e você poderá
remover a caixa que fica em volta dele por meio da barra de propriedades.

31
Para colocar a legenda no gráfico, basta clicar com o botão direito do mouse na parte branca do
gráfico e escolher a opção Show Legend, a legenda pode ser editada dando duplo clique sobre o texto
que apareceu.
Outros comandos importantes:
𝑓𝑖𝑔𝑢𝑟𝑒: inicia uma nova janela gráfica.
𝑙𝑒𝑔𝑒𝑛𝑑(‘𝑡𝑒𝑥𝑡𝑜1’, ’𝑡𝑒𝑥𝑡𝑜2’, . . . , ’𝑡𝑒𝑥𝑡𝑜𝑛’): coloca legenda numa figura para 𝑛 curvas.
OUTROS TIPOS DE GRÁFICOS
polar: gera gráficos com eixos de coordenadas polares. Ex.:
𝑡ℎ𝑒𝑡𝑎 = −2 ∗ 𝑝𝑖: 0.1: 2 ∗ 𝑝𝑖;

𝑟ℎ𝑜 = 1: 𝑠𝑖𝑧𝑒(𝑡ℎ𝑒𝑡𝑎, 2);
𝑝𝑜𝑙𝑎𝑟(𝑡ℎ𝑒𝑡𝑎, 𝑟ℎ𝑜,′ 𝑟+′ )
plotyy: permite criar duas curvas no mesmo gráfico com escalas Y diferentes. Ex.:
𝑥 = 0: 0.1: 10;
𝑠𝑢𝑏𝑝𝑙𝑜𝑡(1,2,1)
𝑝𝑙𝑜𝑡(𝑥, sin(𝑥) , 𝑥, exp(𝑥))
𝑠𝑢𝑏𝑝𝑙𝑜𝑡(122)
𝑝𝑙𝑜𝑡𝑦𝑦(𝑥, sin(𝑥) , 𝑥, exp(𝑥))
EIXOS
Para configurar as propriedades dos eixos, pode-se usar as seguintes funções:
𝑎𝑥𝑖𝑠([𝑋𝑚𝑖𝑛⁡𝑋𝑚𝑎𝑥⁡𝑌𝑚𝑖𝑛⁡𝑌𝑚𝑎𝑥])
𝑔𝑟𝑖𝑑: determina se o gráfico terá ou não uma grade, pode-se usar junto à on ou off. Caso não
seja especificado ele colocará a grade ou removerá dependendo do modo que esteja setado. O padrão é
a grade no modo off.
𝑔𝑟𝑖𝑑(′𝑜𝑛′ )
𝑏𝑜𝑥: por padrão existe uma caixa que fica em volta do gráfico, e ela irá aparecer, caso deseje
apagar essa caixa, basta usar o comando 𝑏𝑜𝑥.
𝑎𝑥𝑒𝑠: cria um eixo em uma posição específica da janela.
𝑎𝑥𝑒𝑠(′𝑝𝑜𝑠𝑖ç𝑎𝑜′ , [𝑋𝑖𝑛𝑖𝑐⁡𝑌𝑖𝑛𝑖𝑐𝑖⁡𝐷𝑥⁡𝐷𝑦])
Faça o seguinte exemplo:
Janela total: 𝑎𝑥𝑒𝑠(′𝑝𝑜𝑠𝑖𝑡𝑖𝑜𝑛′ , [0⁡0⁡1⁡1])
¼ da Janela: 𝑎𝑥𝑒𝑠(′𝑝𝑜𝑠𝑖𝑡𝑖𝑜𝑛′ , [0.5⁡0.5⁡0.25⁡0.25])

32
EXPORTANDO GRÁFICOS
Para exportar gráficos, pode-se usar o comando de impressão 𝑝𝑟𝑖𝑛𝑡. Este comando irá imprimir
o gráfico para um arquivo de imagem.
print(Dispositivo, Opções, ‘Nome_arquivo’)
Dispositivo é o tipo de saída, existem vários dispositivos, consulte o help, usaremos aqui o
comando –djpeg.
Opções está relacionada com as opções de impressão, nesse caso usaremos –r300, relacionado à
resolução de 300dpi.
E vamos salvar o arquivo com o nome de grafico (sem acento).
Outra forma de se obter a imagem de um jeito mais prático é através do menu

Edit/Copy Figure.
HANDLE
Esse meio de trabalho é muito usado em programação orientada à objeto e está relacionada com
o acesso das propriedades de cada item em um gráfico. É um pouco complicada a utilização deles, mas
explicarei algumas formas de acesso a eles aqui.
Vamos ao seguinte exemplo:
ℎ𝑓 = 𝑓𝑖𝑔𝑢𝑟𝑒(1)
a variável ℎ𝑓 armazena o ℎ𝑎𝑛𝑑𝑙𝑒 da janela figura 1. Vamos criar dois eixos na figura.
ℎ𝑎1 = 𝑎𝑥𝑒𝑠(′𝑃𝑜𝑠𝑖𝑡𝑖𝑜𝑛′ , [0.1⁡0.1⁡0.35⁡0.8]);

ℎ𝑎2 = 𝑎𝑥𝑒𝑠(′𝑃𝑜𝑠𝑖𝑡𝑖𝑜𝑛′ , [0.55⁡0.1⁡0.35⁡0.8]);
para colocar gráficos em cada um dos eixos, basta setar o eixo corrente. Exemplo:
𝑎𝑥𝑒𝑠(ℎ𝑎1)
𝑥 = −2 ∗ 𝑝𝑖: 0.1: 2 ∗ 𝑝𝑖;
𝑝𝑙𝑜𝑡(𝑥, sin(𝑥))
𝑎𝑥𝑒𝑠(ℎ𝑎2)
[𝑎⁡𝑚] = 𝑖𝑚𝑟𝑒𝑎𝑑(′𝑖𝑚𝑎𝑔𝑒𝑚. 𝑏𝑚𝑝′ );
𝑖𝑚𝑎𝑔𝑒(𝑎)
Repare que no segundo exemplo, deve existir uma imagem dentro da pasta. A seguir vamos
verificar outros exemplos de acesso ao ℎ𝑎𝑛𝑑𝑙𝑒.
graficos_handle.m
function graficos_handle ( )
hf1=figure(1);
ha=axes(‘Position’,[0.1 0.1 0.8 0.8]);
axis([0 10 0 10]);

33
%cria uma linha

X1=[1 3 5 7 9];
Y1=[1 5 2 9 5];
h1=line(X1,Y1);
%cria um retângulo
hr=rectangle(‘Position’,[6 1 3 2]);
%criando um polígono : hexágono vermelho

x=linspace(0.2*pi,7);
hp=patch(3+cos(x),8+sin(x),’r’);
%cria textos
ht1=text(1.5,3.5,’Line’);
ht2=text(7,1.5,’Rectangle’);
ht3=text(2,9.5,’Patch’);
Acesso aos objetos Handle Graphics
As propriedades dos objetos podem ser alteradas após a criação deles usando as funções abaixo:
ℎ𝑓 = 𝑔𝑐𝑓: da janela de figura corrente
ℎ𝑎 = 𝑔𝑐𝑎: do eixo corrente
ℎ𝑜 = 𝑔𝑐𝑜: do objeto corrente
𝑐𝑙𝑓: limpa a figura corrente
𝑠ℎ𝑔: mostra a figura corrente
ℎ𝑠 = 𝑓𝑖𝑛𝑑𝑜𝑏𝑗(𝑃𝑟𝑜𝑝𝑟𝑖𝑒𝑑𝑎𝑑𝑒, 𝑣𝑎𝑙𝑜𝑟): retorna o handle do objeto que satisfaz a condição

propriedade = valor.
𝑣𝑎𝑙𝑜𝑟 = 𝑔𝑒𝑡(ℎ𝑎𝑛𝑑𝑙𝑒, 𝑝𝑟𝑜𝑝𝑟𝑖𝑒𝑑𝑎𝑑𝑒): retorna o valor da propriedade consultada.
𝑠𝑒𝑡(ℎ𝑎𝑛𝑑𝑙𝑒, 𝑝𝑟𝑜𝑝𝑟𝑖𝑒𝑑𝑎𝑑𝑒, 𝑣𝑎𝑙𝑜𝑟): configura a propriedade com o valor fornecido.
Exemplos:
x=-2*pi:0.1:2*pi;
plot(x,sin(x))
h=findobj(‘Type’,’line’) %obtem handle da curva
c=get(h,’linestyle’) %obtem tipo de estilo de linha
set(h,’linestyle’,’.’)%configura o novo estilo de linha

34
grafico_ex.m
function grafico_ex ( )
x=-2:0.2:2;
y=-5:0.2:5;
[X,Y]=meshgrid(x,y);
Z=exp(sin(X)).*cos(Y);
surf(Z)
light(‘Position’,[0 0 2]); %cria luz nessa posição
h = gca;
set(h,’cameraposition’,[100 300 30]); %reposiciona a câmera
tempo=1:12;
chuva=[3 4 8 5 7 4 3 8 5 7 6 2];
plot(tempo,chuva)
ha=gca;
meses = {'Jan' 'Fev' 'Mar' 'Abr' 'Mai' 'Jun' 'Jul' 'Ago' 'Set' 'Out' 'Nov' 'Dez'};
set(ha,’Xtick’,tempo);
set(ha,’XtickLabel’,meses);
shg %mostra a figura
A seguir serão explicados outras formas de se trabalhar com gráficos:
𝑎𝑟𝑒𝑎: gera um gráfico de área;
𝑏𝑎𝑟: gera um gráfico com barras verticais;
𝑏𝑎𝑟ℎ: gera um gráfico com barras horizontais;
𝑠𝑡𝑎𝑖𝑟𝑠: gráfico escada;
𝑝𝑖𝑒: gráfico de pizza;
𝑠𝑐𝑎𝑡𝑡𝑒𝑟: gráfico discreto com pontos;
𝑠𝑡𝑒𝑚: gráfico discreto com hastes.
comet: gráfico animado com trajetória de cometa;
compass: gráfico com fasores no plano polar;
feather: gráfico com representação vetorial no plano cartesiano (sem as setas).
ang=0:0.5:2*pi;
raio = linspace(0,2,13);
subplot(131)
polar(ang,raio)
title(‘POLAR’)
subplot(132)
[x,y]=pol2cart(ang,raio);
compass(x,y);
title(‘COMPASS’)
subplot(133)
feather(x,y)
title(‘FEATHER’)

35
Pode-se usar ainda os commandos 𝑒𝑧𝑝𝑙𝑜𝑡 para graficar funções no plano cartesiano e, também,
𝑒𝑧𝑝𝑜𝑙𝑎𝑟 para o plano polar.
subplot(231)
ezplot('x*cos(x)')
subplot(232)
ezplot('1/exp(x)')
subplot(233)
ezplot('x^2-2*x+1-10*sin(x)')
subplot(234)
ezpolar('cos(t)')
subplot(235)
ezpolar('sin(t)+cos(t)')
subplot(236)
ezpolar('t*(sin(t)+cos(t))')
GRÁFICOS 3D
Nessa seção será demonstrado o uso de funções relacionadas à gráficos 3D.
𝑝𝑙𝑜𝑡3: cria uma curva no espaço 3D.
𝑚𝑒𝑠ℎ𝑔𝑟𝑖𝑑: dados dois vetores, x e y, contendo as coordenadas dos eixos X e Y, retorna duas
matrizes, MX e MY, contendo a malha de coordenadas necessária para a geração de superfícies.
𝑚𝑒𝑠ℎ: gráfico de malha.
𝑠𝑢𝑟𝑓. Gráfico de superfície.
𝑚𝑒𝑠ℎ𝑐, 𝑚𝑒𝑠ℎ𝑧, 𝑤𝑎𝑡𝑒𝑟𝑓𝑎𝑙𝑙, 𝑠𝑢𝑟𝑓𝑐: variações de gráficos de malhas e superfícies.
𝑐𝑦𝑙𝑖𝑛𝑑𝑒𝑟: retorna as malhas de coordenadas MX, MY e MZ para a criação de um cilindro com

altura 1. [𝑚𝑥, 𝑚𝑦, 𝑚𝑧] = 𝑐𝑦𝑙𝑖𝑛𝑑𝑒𝑟(𝑟𝑎𝑖𝑜, 𝑛); onde n é o número de faces (padrão = 20).
𝑠𝑝ℎ𝑒𝑟𝑒: malhas para uma esfera de raio 1.
𝑒𝑙𝑙𝑖𝑝𝑠𝑜𝑖𝑑: malhas para a criação de um elipsoide.
Outros comandos:
𝑏𝑎𝑟3, 𝑏𝑎𝑟3ℎ, 𝑝𝑖𝑒3, 𝑐𝑜𝑚𝑒𝑡3, 𝑟𝑖𝑏𝑏𝑜𝑛, 𝑐𝑜𝑛𝑡𝑜𝑢𝑟, 𝑐𝑜𝑛𝑡𝑜𝑢𝑟𝑓, 𝑐𝑜𝑛𝑡𝑜𝑢𝑟3.
Para plotar gráficos 3D com o uso de funções basta acrescentar 𝑒𝑧 antes dos comandos.

36
10. INTERFACE COM USUÁRIO – GUIDE (Graphic User Interface Design

Environment)
“Existem 10 tipos de pessoa no mundo, as que

sabem binário, e as que não sabem”.
Muito bem, já vimos em capítulos anteriores que podemos pedir para que o usuário digite um
valor por meio da função 𝑖𝑛𝑝𝑢𝑡. Veremos nesse capítulo como criar outras formas de iteração com o
usuário.
Uma forma de verificar se o usuário entrou com algum dado é usar a função 𝑖𝑠𝑒𝑚𝑝𝑡𝑦(𝑣𝑎𝑟).
n = input(‘Digite um número: ‘);

if isempty(n)
display(‘Valor não fornecido’);
end
CAIXA DE DIÁLOGO
As caixas de diálogo são acessadas pelo comando 𝑖𝑛𝑝𝑢𝑡𝑑𝑙𝑔.
msg={‘Largura:’ ‘Altura:’};
titulo=’Dimensões do Retângulo`;
numlinhas=[1 2]’;
valpredef={‘500’ ‘100’};
dados=inputdlg(msg,titulo,numlinhas,valpredef);
𝑎𝑥𝑙𝑖𝑚𝑑𝑙𝑔: caixa de diálogo para definição dos eixos.
𝑎𝑥𝑙𝑖𝑚𝑑𝑙𝑔(′𝐷𝑒𝑓𝑖𝑛𝑎⁡𝑜𝑠⁡𝑒𝑖𝑥𝑜𝑠 ′ )
𝑞𝑢𝑒𝑠𝑡𝑑𝑙𝑔: caixa de diálogo com dois botões para resposta
>>pergunta=’está certo disso?’;

>>titulo=’pergunta’;
>>botao1=’Sim’;
>>botao2=’Não’;
>>padrao=’Sim’;
>>resp=questdlg(pergunta,titulo,botao1,botao2,padrao);
MENSAGENS PARA USUÁRIOS
É possível enviar mensagens aos usuários da seguinte forma:
Mensagem de erro: 𝑒𝑟𝑟𝑜𝑟𝑑𝑙𝑔(‘𝑀𝑒𝑛𝑠𝑎𝑔𝑒𝑚’, ’𝑇í𝑡𝑢𝑙𝑜⁡𝑑𝑎⁡𝑐𝑎𝑖𝑥𝑎’)
Mensagem de aviso: 𝑤𝑎𝑟𝑛𝑑𝑙𝑔(‘𝑀𝑒𝑛𝑠𝑎𝑔𝑒𝑚’, ’𝑇í𝑡𝑢𝑙𝑜⁡𝑑𝑎⁡𝑐𝑎𝑖𝑥𝑎’)
Mensagem de ajuda: ℎ𝑒𝑙𝑝𝑑𝑙𝑔(‘𝑀𝑒𝑛𝑠𝑎𝑔𝑒𝑚’, ’𝑇í𝑡𝑢𝑙𝑜⁡𝑑𝑎⁡𝑐𝑎𝑖𝑥𝑎’)

37
LISTAS
Para se trabalhar com listas usa-se o comando 𝑙𝑖𝑠𝑡𝑑𝑙𝑔 da seguinte forma:
>>prompt=’mapeamento de cores’;
>>lista={‘autumn’ ‘bone’ ‘cool’ ‘default’};
>>[Ind,ok]=listdlg(‘promptstring’,prompt,’liststring’,lista);
A variável Ind retornará a opção selecionada e a variável Ok retornará se o usuário clicou no

botão (1) ou não (0).
Outras propriedades de entrada:
‘PromptString’: Texto da caixa
‘ListString’: lista de opções
‘InitialValue’: índice da opção inicial
‘SelectMode’: ‘multiple’/’single’
‘ListSize’: largura e altura [larg alt].
‘Name’: título da caixa de diálogo
CAIXAS DE CONFIGURAÇÃO PARA FIGURAS
𝑝𝑎𝑔𝑒𝑑𝑙𝑔: Exibe uma caixa de diálogo de posicionamento de página para figura correspondente
ao handle fornecido.
𝑝𝑎𝑔𝑒𝑑𝑙𝑔(𝑔𝑐𝑓)
𝑝𝑎𝑔𝑒𝑠𝑒𝑡𝑢𝑝𝑑𝑙𝑔: caixa de diálogo para configuração de página.
𝑝𝑟𝑖𝑛𝑡𝑑𝑙𝑔: caixa de diálogo de impressão.
𝑝𝑟𝑖𝑛𝑡𝑝𝑟𝑒𝑣𝑖𝑒𝑤: caixa de diálogo de pré-visualização de impressão.

38
ARQUIVOS
𝑢𝑖𝑔𝑒𝑡𝑓𝑖𝑙𝑒: caixa de diálogo para abertura de arquivos.
[nome, caminho]=uigetfile({‘*.mat’}, ‘Escolha um arquivo’);

if ~ischar(nome) %verifica se algum dado foi fornecido
warndlg(‘Nome de arquivo não fornecido’);
else
Arquivo=fullfile(caminho,nome);%compoe nome do arquivo
load(Arquivo);
if (exist(‘Xd’) & exist(‘Yd’)) %verifica se as variaveis existem
plot(Xd,Yd);
shg;
else
errordlg(‘Variaveis Xd e Yd não definidas.’);
end
end
𝑢𝑖𝑜𝑝𝑒𝑛: equivale a opção Abrir do menu Arquivo.
𝑢𝑖𝑙𝑜𝑎𝑑: chama a caixa de diálogo que permite carregar um arquivo *.mat.
𝑢𝑖𝑝𝑢𝑡𝑓𝑖𝑙𝑒: caixa de diálogo de gravação de arquivo.
>>tipo={‘*.mat’;’*.fig’};
>>titulo=’grava arquivo’;
>>[nome,caminho]=uiputfile(tipo,titulo);
𝑢𝑖𝑠𝑎𝑣𝑒: caixa de dialogo que permite armazenar um arquivo. Equivale a opção Save Workspace.
𝑢𝑖𝑠𝑒𝑡𝑐𝑜𝑙𝑜𝑟: caixa de diálogo de configuração de cores.
𝑢𝑖𝑠𝑒𝑡𝑓𝑜𝑛𝑡: caixa de diálogo de configuração de fontes. No exemplo abaixo, muda-se a fonte do

eixo do gráfico.
>>f=uisetfont(gca,’Fonte de texto’)
𝑢𝑖𝑖𝑚𝑝𝑜𝑟𝑡: caixa de diálogo para importar dados. Equivale a opção Import Date.
𝑤𝑎𝑖𝑡𝑏𝑎𝑟: caixa de diálogo de barra de tempo de execução.
function interface01 ( )
h = waitbar(0,’Em execução, por favor, aguarde...’);
for i=1:50
waitbar(i/50,h);
z=rand(10);
contour(z);
end
close(h)

39
11. TRANSFORMADAS
Quando um médico não consegue explicar fala que é virose, quando um

eletricista não consegue explicar fala que é harmônico e quando um
filósofo não consegue explicar chama de Deus
Esse capítulo trata das transformadas de Laplace, Z e Fourier, poderia ter sido inserido junto ao
capítulo de Símbolos, porém, preferi colocá-lo a parte. O objetivo desse capítulo é apenas mostrar o uso
das transformadas e não explicar a parte de cálculo das mesmas.
Considere os símbolos 𝑥, 𝑦, 𝑡, 𝑎, 𝑏⁡e 𝑐.
TRANSFORMADA DE LAPLACE
Para calcular a Transformada de Laplace ou Transforma de Laplace Inversa usamos os

comandos 𝑙𝑎𝑝𝑙𝑎𝑐𝑒 e 𝑖𝑙𝑎𝑝𝑙𝑎𝑐𝑒, respectivamente. Alguns exemplos:
>>l=laplace(sin(t))
>>pretty(l)
>>l=ilaplace(1/(t^2+1))
>> f=5*exp(-5*t)
f =
5*exp(-5*t)
>> laplace(f) % calcula a Transformada de Laplace de f
ans =
5/(s+5)
>> g=t^2+5*t-6;
>> laplace(g) % calcula a Transformada de Laplace de g
ans =
2/s^3+5/s^2-6/s
>> syms s
>> ilaplace(1/sqrt(s)) % calcula a Transformada de Laplace Inversa
ans =
1/(pi*t)^(1/2)
>> h=(2*s+2)/(s^2+7*s+12) % define h
h =
(2*s+2)/(s^2+7*s+12)
>> ilaplace(h) % calcula a Transformada de Laplace Inversa de h(s)
ans =
-4*exp(-3*t)+6*exp(-4*t)
De forma análoga à Transformada de Laplace, a Transformada Z e a Transformada de Fourier

podem ser calculadas por intermédio dos comandos 𝑧𝑡𝑟𝑎𝑛𝑠 e 𝑓𝑜𝑢𝑟𝑖𝑒𝑟, respectivamente

40
TRANSFORMADA DE FOURIER
A Transformada de Fourier de uma função f é definida como:
𝑓(𝑥), 𝑥 é a variável independente.

∞
𝐹(𝜔) = ∫ 𝑓(𝑥) ∙ 𝑒 −𝑖𝑥𝜔 𝑑𝑥
−∞
𝑓𝑜𝑢𝑟𝑖𝑒𝑟: faz a transformada de Fourier.
𝑖𝑓𝑜𝑢𝑟𝑖𝑒𝑟: faz a transformada inversa de Fourier.
>>f=fourier(exp(-x^2),x,t)
>>pretty(f)
>>f1=ifourier(exp(-x^2),x,t)
>>pretty(f1)
>> syms x
>> f=exp(-x^2)
f =
exp(-x^2)
>> fourier(f)
ans =
pi^(1/2)*exp(-1/4*w^2)
>> h=x*exp(-abs(x))
h =
x*exp(-abs(x))
>> fourier(h)
ans =
-4*i/(1+w^2)^2*w
TRANSFORMADA Z
A Transformada Z (unilateral) de uma função f é definida como:

∞
𝑍[𝑓] = ∑ 𝑓(𝑛)𝑧 −𝑛
𝑛=0
>> syms n
>> f=n^4
f =
n^4
>> sol=ztrans(f)
sol =
z*(z^3+11*z^2+11*z+1)/(z-1)^5
>> pretty(sol)
>>ztrans(t^2)
>>z1=iztrans((1+z)/(z-1)^3)

41
12. CONTROLE ANALÓGICO E DIGITAL
“O verdadeiro perigo não é que computadores começarão a pensar como

homens, mas que homens começarão a pensar como computadores.”
Sydney J. Harris
Esse capítulo abordará algumas funções para se trabalhar com o uso de ferramentas para
controle analógico e digital, não será um aprofundamento sobre a matéria, mas apenas alguns recursos
que poderão servir para conhecimento da área.
As funções abordadas aqui são muito simples e exigem apenas o conhecimento da transformada
de Laplace e Z.
FUNÇÃO DE TRANSFERÊNCIA
Dada a função de transferência:
1
𝐹(𝑠) =
𝑠+1
Tem-se que 𝑛 = [1], e 𝑑 = [1⁡1]. Portanto, para a montagem da função usa-se o comando 𝑡𝑓
(transfer function).
𝑣𝑎𝑟 = 𝑡𝑓(𝑛, 𝑑)
A seguir, pode-se aplicar algumas funções básicas para o estudo do comportamento da função
de transferência.
𝑠𝑡𝑒𝑝(𝑣𝑎𝑟)
𝑖𝑚𝑝𝑢𝑙𝑠𝑒(𝑣𝑎𝑟)
A função 𝑠𝑡𝑒𝑝 é a função degrau. E a função 𝑖𝑚𝑝𝑢𝑙𝑠𝑒 é a função impulso.
𝑐2𝑑(𝑠𝑦𝑠, 𝑡𝑑, 𝑚𝑒𝑡𝑜𝑑𝑜): converte uma função do domínio contínuo para o domínio discreto.
𝑑2𝑐: converte do domínio discreto para o domínio contínuo.
[𝑅, 𝑃, 𝐾] = 𝑟𝑒𝑠𝑖𝑑𝑢𝑒(𝐴, 𝐵): separa em frações parciais a divisão do polinômio A por B.
𝑏𝑜𝑑𝑒(𝑣𝑎𝑟): monta o diagrama de bode da função.
Outros recursos podem ser conferidos no material em anexo.

42
13. OUTRAS FUNÇÕES INTERESSANTES
Deixei de gostar da matemática, depois que x

deixou de ser sinal de multiplicação.
Esse capítulo abordará algumas funções que considerei interessantes para serem discutidas:
𝑣𝑝𝑎(𝑉, 𝑑): valor numérico de cada elemento fornecido utilizando a precisão numérica solicitada.
𝑣𝑝𝑎(𝑝𝑖, 3)
𝑣𝑝𝑎(𝑝𝑖, 20)
𝑚3 = 𝑣𝑝𝑎(𝑖𝑛𝑣([1⁡2; 5⁡7], 2)
𝑚𝑛 = 𝑑𝑜𝑢𝑏𝑙𝑒(𝑚3)
𝑤ℎ𝑜⁡𝑚3⁡𝑚𝑛
𝑝𝑜𝑙𝑦2𝑠𝑦𝑚(𝑐𝑜𝑒𝑓, 𝑣𝑎𝑟): converte vetor numérico contendo coeficientes de polinômio em um

objeto simbólico.
𝑠𝑦𝑚2𝑝𝑜𝑙𝑦: converte polinômio em formato de objeto simbólico em vetor numérico.
𝑐ℎ𝑎𝑟: converte símbolos em caracteres.
𝑙𝑎𝑡𝑒𝑥: converte símbolos em formato LaTex.
𝑓𝑢𝑛𝑡𝑜𝑜𝑙: calculadora de funções.
𝑡𝑎𝑦𝑙𝑜𝑟𝑡𝑜𝑜𝑙: calculadora da série de Taylor.
ARREDONDAMENTO
𝑛𝑒𝑥𝑡𝑝𝑜𝑤2(𝑛𝑢𝑚): mostra o próximo número da potência de 2.
𝑓𝑖𝑥(𝑥): arredonda para o inteiro mais próximo de 0.
𝑓𝑙𝑜𝑜𝑟(𝑥): arredonda para o inteiro mais próximo de – 𝑖𝑛𝑓.
𝑐𝑒𝑖𝑙(𝑥): arredonda para o inteiro mais próximo de +𝑖𝑛𝑓.
𝑟𝑜𝑢𝑛𝑑(𝑥): arredonda para o inteiro mais próximo.
𝑟𝑒𝑚(𝑥, 𝑦): resto da divisão de x por y, com sinal de x.
TEORIA DOS NÚMEROS
𝑓𝑎𝑐𝑡𝑜𝑟(𝑛𝑢𝑚): fatora em números primos
𝑖𝑠𝑝𝑟𝑖𝑚𝑒(𝑛𝑢𝑚): verifica se o número é primo
𝑝𝑟𝑖𝑚𝑒𝑠(𝑛𝑢𝑚): mostra os números primos até o número determinado.
𝑔𝑐𝑑: retorna o MDC.

43
𝑙𝑐𝑚: retorna o MMC.
𝑟𝑎𝑡(𝑛𝑢𝑚): mostra a parte inteira somada de fração.
𝑟𝑎𝑡𝑠(𝑛𝑢𝑚): mostra a fração que compõe o número.
𝑝𝑒𝑟𝑚𝑠(𝑣𝑒𝑡𝑜𝑟): retorna todas as permutações possíveis dos números dados.
𝑛𝑐ℎ𝑜𝑜𝑠𝑒𝑘(𝑣𝑒𝑡𝑜𝑟, 𝑐𝑜𝑛𝑗𝑢𝑛𝑡𝑜): retorna todas as permutações do conjunto dado.
𝑚𝑎𝑥: retorna o valor máximo.
𝑚𝑖𝑛: retorna o valor mínimo.
𝑚𝑒𝑎𝑛: retorna a média
𝑚𝑒𝑑𝑖𝑎𝑛: retorna a mediana
𝑠𝑡𝑑: retorna o valor padrão
𝑣𝑎𝑟: retorna a variância
𝑐𝑜𝑣: retorna a covariância
𝑠𝑜𝑟𝑡: classifica os elementos em ordem crescente, por coluna.
𝑠𝑜𝑟𝑡𝑟𝑜𝑤𝑠: classifica elementos em ordem crescente, por linhas.
𝑠𝑢𝑚: retorna soma dos elementos.
𝑝𝑟𝑜𝑑: retorna produto dos elementos.
𝑡𝑟𝑎𝑝𝑧: retorna a integral numérica trapezoidal.
𝑐𝑢𝑚𝑠𝑢𝑚: retorna vetor com soma acumulada.
𝑐𝑢𝑚𝑝𝑟𝑜𝑑: retorna vetor com produto acumulado.
𝑐𝑢𝑚𝑡𝑟𝑎𝑝𝑧: retorna vetor com integral trapezoidal acumulada.

44
TRANSFORMAÇÃO DE COORDENADAS
𝑐𝑎𝑟𝑡2𝑝𝑜𝑙: converte de coordenadas cartesianas para polares. 𝑝𝑜𝑙2𝑐𝑎𝑟𝑡 faz o inverso.
𝑐𝑎𝑟𝑡2𝑠𝑝ℎ: cartesiana para esféricas.
ℎ𝑒𝑥2𝑛𝑢𝑚: hexadecimal em numérico.
ℎ𝑒𝑥2𝑑𝑒𝑐: hexa em decimal.
𝑏𝑖𝑛2𝑑𝑒𝑐: binário em decimal.
𝑏𝑎𝑠𝑒2𝑑𝑒𝑐: converte base dada em decimal.
𝑏𝑎𝑠𝑒2𝑑𝑒𝑐(6,4)
ANÁLISE MATRICIAL
𝑛𝑜𝑟𝑚: retorna a norma da matriz.
𝑟𝑎𝑛𝑘: retorna o posto da matriz.
𝑡𝑟𝑎𝑐𝑒: retorna soma dos elementos da diagonal, (soma de autovalores).
𝑛𝑢𝑙𝑙: retorna base do subespaço nulo (kernel) da matriz.
𝑜𝑟𝑡ℎ: ortogonaliza matriz.
𝑠𝑢𝑏𝑠𝑝𝑎𝑐𝑒: retorna ângulo entre os subespaços.
𝑙𝑢: fatoração LU.
𝑝𝑜𝑙𝑦: retorna o polinômio característico da matriz.
𝑔𝑟𝑎𝑑𝑖𝑒𝑛𝑡: retorna gradiente numérico da matriz.
FILTROS E TRANSFORMADA DE FOURIER
𝑓𝑖𝑙𝑡𝑒𝑟: filtro unidimensional (filtro IIR ou FIR)
𝑓𝑖𝑙𝑡𝑒𝑟2: filtro bidimensional (filtro FIR)
𝑓𝑓𝑡: Transformada rápida de Fourier

45
14. SIMULINK
"Errar é humano, colocar a culpa no computador é mais humano ainda."
Simulink é uma ferramenta do MatLab responsável pela simulação a partir do uso de blocos, é
uma ferramenta muito simples, prática e útil. A seguir veremos algumas formas de se trabalhar com
ele. Primeiramente, para acessar o programa, digite “simulink” (sem aspas) no Command Window.
Clique no botão de novo, e arraste os blocos desejados para a janela.
BLOCOS DE ENTRADA (FONTES)
São as entradas do sistema e estão presentes na biblioteca de fontes (sources). A seguir, as

fontes mais comuns:
O bloco Constante (Constant) produz um sinal uniforme. A magnitude pode ser escolhida
com um duplo clique sobre o bloco.
O bloco Degrau (Step) produz uma função degrau. Pode-se configurar o instante em que se
aplica o degrau, assim como sua magnitude antes e depois da transição.
O bloco de Onda Senoidal (Sine Wave) gera uma senóide com os seguintes parâmetros a
serem configurados: amplitude, fase e frequência da onda senoidal.
O Gerador de Sinais (Signal Generator) pode produzir ondas senoidais, quadradas, dente de
serra ou sinais aleatórios.

46
DIAGRAMA DE BLOCOS
Através de combinações de blocos da biblioteca pode-se obter sinais personalizados.
BLOCOS DE SAÍDA
Os dispositivos de saída são os blocos que permitem verificar o comportamento do sistema,

estes blocos são encontrados na biblioteca de dispositivos de saída (Sinks).
Scope: O osciloscópio produz gráficos a partir de dados do modelo. Não existem parâmetros a
serem configurados.
XY Graph: O bloco de XY Graph produz um gráfico idêntico ao gráfico produzido pelo

comando plot do MATLAB. Para isso, devem-se configurar os valores de mínimos e máximos, da
horizontal e vertical.
Display: O bloco Display produz uma amostragem digital do valor de sua entrada.
To File: Pode-se ainda armazenar os dados em arquivos doMATLAB para usos posteriores.
Deve-se definir o nome do arquivo a ser criado.
To Workspace: Pode-se ainda enviar os dados para a área de trabalho do MATLAB utilizando
o bloco To Workspace Block. Deve-se definir o nome da matriz.
Stop Simulation: O bloco de parada (Stop Simulation) causa a parada da simulação quando a
sua entrada for diferente de zero.
EXEMPLOS

47
Configure o gerador de sinais com as seguintes propriedades:
Forma de onda: Sawtooth (dente de serra), frequência de 1 Hz e amplitude de 2. Defina o tempo

de simulação igual a 20.
Outro exemplo: 𝑥(𝑡) = ∫ sen(𝑥) 𝑑𝑡.
CONTROLE
No Simulink, nos blocos de Continuos existem comandos que serão usados para representar o
controle contínuo. Inicialmente, vamos fazer alguns exemplos simples.
Sem Retroalimentação
Com Retroalimentação

48
FIM
Ahhhhhh … que pena!!! Chegamos ao final do nosso estudo sobre recursos avançados do
MatLab. Espero que todos tenham gostado do curso, caso tenha dúvidas podem entrar em contato por
e-mail: rcmonzani@gmail.com.
THAT’S ALL FOLKS!!!

Curso Matlab

Enviado por

Dados do documento

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

Curso Matlab

Enviado por

Direitos autorais:

Formatos disponíveis

Departamento de Elétrica

Prof. Rafael Cuerda Monzani

O MatLab é um programa do tipo simulador matemático, onde é possível realizar, de maneira

TELA INICIAL DO PROGRAMA

Inicialmente será apresentada a tela do programa, descrevendo cada um de seus componentes.

Figura 1.1 – Janela Inicial do MatLab

Prof. Rafael Cuerda Monzani – IFSP/SPO/DEL

Os componentes apresentados na figura acima serão descritos abaixo:

Workspace: é o local onde as variáveis são apresentadas, em relação a nome e tamanho.

Prof. Rafael Cuerda Monzani – IFSP/SPO/DEL

"O estudo da ciência da computação não consegue transformar qualquer um

O programa executa as funções lançadas diretamente no Command Window, como segue no

𝑣𝑒𝑡 = [15⁡92⁡75];  vetor linha

𝑣𝑒𝑡 = [15; 92; 75];  vetor coluna

𝑣𝑒𝑡 = [ ]  conjunto vazio

Prof. Rafael Cuerda Monzani – IFSP/SPO/DEL

Basta associar a união de um vetor linha com um vetor coluna.

𝑚𝑎𝑡𝑟𝑖𝑧 = [1⁡2⁡3; 4⁡5⁡6; 7⁡8⁡9];

𝑚𝑎𝑡𝑟𝑖𝑧(𝑙𝑖𝑛ℎ𝑎, 𝑐𝑜𝑙𝑢𝑛𝑎) → 𝑒𝑙𝑒𝑚𝑒𝑛𝑡𝑜

𝑚𝑎𝑡𝑟𝑖𝑧(3,3) = 10;  muda o valor do elemento 3,3.

OBSERVAÇÃO: o MatLab é case sensitive, ele diferencia letras maiúsculas de minúsculas. A

Os operadores básicos para serem utilizados são:

A/B : divisão de A por B

A\B : divisão de B por A

Montagem de vetor: 𝑡 = 𝑣𝑎𝑙𝑜𝑟_𝑖𝑛𝑖𝑐𝑖𝑎𝑙: 𝑝𝑎𝑠𝑠𝑜: 𝑣𝑎𝑙𝑜𝑟_𝑓𝑖𝑛𝑎𝑙

Acesso de matrizes: 𝑚𝑎𝑡𝑟𝑖𝑧(1, : )  pega todos os elementos da linha 1 da matriz.

OBSERVAÇÃO MUITO IMPORTANTE: os vetores precisam ser do mesmo tamanho.

Prof. Rafael Cuerda Monzani – IFSP/SPO/DEL

OUTRA OBSERVAÇÃO MUITO IMPORANTE: NÃO TENHA PREGUIÇA DE LER OS

Matrix dimensions must agree.  as matrizes não são do mesmo tamanho

length(vetor): mostra o tamanho do vetor, independentemente se é coluna ou linha

size(matriz): mostra o tamanho da matriz, o primeiro número está associado ao número de

ACESSO DE DIRETÓRIOS (PASTAS)

Comandos usados para acesso a diretórios:

cd ou pwd: informa o diretório atual (que já está la na parte de cima do MatLab).

what: mostra OS ARQUIVOS do diretório, a diferença é q o dir mostra até as pastas.

!: chama um comando do sistema operacional. Ex.: !del executar.m

Prof. Rafael Cuerda Monzani – IFSP/SPO/DEL

CONSTANTES PRÉ DEFINIDAS

O MatLab possui algumas constantes pré-definidas como por exemplo:

O MatLab usa pontos e não vírgulas para a separação de casas decimais.

A função exponencial é chamada por exp⁡(𝑣𝑎𝑙𝑜𝑟).

format short: padrão do Matlab, 4 casas após o ponto decimal

format long: 15 casas após o ponto decimal

format rat: formato de fração

sin(x): função seno; cos(x): função cosseno; tan(x): função tangente

asin(x): arco seno; acos(x): arco cosseno; atan(x): arco tangente

Prof. Rafael Cuerda Monzani – IFSP/SPO/DEL

FUNÇÕES BÁSICAS PARA MATRIZES

As funções mais simples são:

𝑑𝑒𝑡(𝐴): calcula o determinante da matriz A.

𝑖𝑛𝑣(𝐴): calcula a inversa da matriz A.

𝑟𝑎𝑛𝑑𝑖([𝑣𝑎𝑙𝑜𝑟_𝑖𝑛𝑖𝑐𝑖𝑎𝑙⁡𝑣𝑎𝑙𝑜𝑟⁡𝑓𝑖𝑛𝑎𝑙], 𝑛, 𝑚): é possível definir a faixa de variação para

𝑒𝑦𝑒(𝑛): cria uma matriz identidade de ordem 𝑛.

𝑧𝑒𝑟𝑜𝑠(𝑛, 𝑚): cria uma matriz de zeros de ordem 𝑛𝑥𝑚.

𝑛𝑢𝑚𝑒𝑙(𝐴): retorna o número de elementos da matriz A.

𝑑𝑖𝑎𝑔(𝐴): retorna os valores da diagonal da matriz A.

𝑡𝑟𝑖𝑙(𝐴): retorna a matriz triangular inferior da matriz A.

𝑡𝑟𝑖𝑢(𝐴): retorna a matriz triangular superior da matriz A.

𝑒𝑖𝑔(𝐴): calcula os autovalores da matriz A.

Para mais funções sobre matrizes, consulte o comando ℎ𝑒𝑙𝑝⁡𝑒𝑙𝑚𝑎𝑡.

Repare que nesse caso para a criação de células, usam-se chaves.

Prof. Rafael Cuerda Monzani – IFSP/SPO/DEL

"A programação hoje em dia é uma corrida entre engenheiros de software