Programação MatLab

Índice de conteúdos
Índice de conteúdos
Capítulo 1.Programação em MatLab.........................................................1

1.A linguagem MatLab................................................................................1
2.Estrutura de um programa.......................................................................1
3.Separadores de comandos........................................................................1
4.Comentários.........................................................................................1
5.Tipos de dados básicos............................................................................2
6.Números complexos...............................................................................3
7.Variáveis.............................................................................................3
8.Variáveis predefinidas (constantes)............................................................4
9.Operadores e expressões.........................................................................4
10.Instrução de atribuição..........................................................................6
11.Matrizes.............................................................................................7
12.O operador ":"....................................................................................12
13.Funções matemáticas básicas................................................................13
14.Funções...........................................................................................15
15.Comandos de leitura/entrada e escrita/saída padrão....................................16
16.Estruturas condicionais........................................................................17
17.Estruturas de repetição........................................................................20
18.O comando error................................................................................22
19.Funções para manipular strings..............................................................23
20.Comandos de leitura e escrita de dados formatadas em ficheiros....................27
21.Estruturas.........................................................................................32
22.Funções gráficas.................................................................................43
-i-
Programação em MatLab
Capítulo 1. Programação em MatLab
1. A linguagem MatLab
O nome MatLab deriva de MATrix LABorator. É um sistema interativo, baseado na representação
matricial para a resolução de problemas, no âmbito científico e de engenharia, e para a sua
visualização gráfica. Possui um conjunto de “Toolboxes” (Sistemas de Controlo, Otimização, Redes
Neuronais Artificiais) que permitem resolver classes particulares de problemas. Tem a possibilidade
de chamar rotinas desenvolvidas em C ou em Fortran.
2. Estrutura de um programa
O MatLab é usado interativamente; isto é, dado um comando, este é interpretado fornecendo os
resultados solicitados. Um programa é uma sequência destes comandos, os quais podem ser escritos
num ficheiro para uma execução posterior. Um programa, para além de comandos, pode também
conter chamadas a funções.
O ficheiro que contém o programa tem que ter a extensão ".m" para ser reconhecido pelo
MatLab; a este ficheiro que contém a sequência de comandos principais, dá-se o nome de script.
Um ficheiro apenas pode conter um programa. Caso este programa faça uma chamada a uma
função, esta tem que estar definida num outro ficheiro. Um ficheiro pode ter mais do que uma
função, sendo que todas as funções, com exceção da primeira, só podem ser chamadas pelas
funções que estejam definidas naquele ficheiro.
3. Separadores de comandos
Para separar comandos podem ser utilizados o <enter>, a virgula (,) ou o ponto e virgula (;). O
<enter> e a virgula (,) executam o comando e, se tiver um resultado, mostra-o no monitor; o ponto
e virgula (;) apenas executa o comando. Podem-se escrever vários comandos na mesma linha, desde
que separados por vírgulas e/ou ponto e vírgulas.
4. Comentários
Um comentário é um texto inserido em qualquer parte do programa ou função, para aumentar a
sua clareza. Um texto precedido pelo caráter "%" é considerado um comentário.
-1-
Tipos de dados básicos
5. Tipos de dados básicos

Existem essencialmente dois tipos de dados básicos: texto e numérico. O tipo de dados texto é
usado para tratar caracteres (char) e cadeias de caracteres (strings). Uma string é composta por
uma cadeia de carateres, delimitada por plicas ('x...x'). Sobre as strings podem ser aplicadas
algumas funções predefinidas, tais como:
- concatenação de várias strings (strcat); ex: strcat('um', 'dois', 'tres') resulta em 'umdoistres'
- determinar o tamanho/comprimento de uma string r (length); ex: lenght('texto') resulta em 5
- determinar o índice do primeiro caráter da string r igual à string s, em que s é uma subcadeia
da cadeia r (findstr); ex: findstr('abcd', 'bc') resulta em 2 e findstr('abcd', 'bck') resulta em vazio.
O tipo de dados numérico tem vários subtipos (dependendo da versão do MatLab), como sejam os
seguintes:
single, double → Números reais (por defeito)
uint8, uint16, uint32, uint64 → Números inteiros sem sinal
int8, int16, int32, int64 → Números inteiros com sinal
Os tipos de dados associados aos números inteiros suportam os seguintes conjuntos de valores:
intB = {-2B-1, ..., 2B-1-1}, B  {8, 16, 32, 64}. Ex: B = 8, int8 = {-27,..., 27-1} = {-128,..., 127}.
uintB = {0, ..., 2B-1}, B  {8, 16, 32, 64}. Ex: B = 8, uint8 = {0,..., 28-1} = {0, ..., 255}.
Um valor numérico é, por defeito, do tipo double (armazenado em 8 Bytes), mas podem ser
usados os outros tipos de dados através da transformação de tipo (casting).
Exemplo:
programa: resultado da execução:
Name Size Bytes Class
A = uint8(89); A 1x1 1 uint8 array
B = int8(89); B 1x1 1 int8 array
C = int16(787); C 1x1 2 int16 array
D = int32(345); D 1x1 4 int32 array
E = uint32(3534); E 1x1 4 uint32 array
X = 4.5; X 1x1 8 double array
Y = double(6.7); Y 1x1 8 double array
Z = single(2.4); Z 1x1 4 single array
whos Grand total is 8 elements using 32 bytes
6. Números complexos
Um número complexo possui a seguinte forma: a + bi. Como MatLab entende as letras i e j como
√(−1), é aconselhado não utilizar tais letras como nomes de variáveis.
-2-
Números complexos
Algumas funções predefinidas para manipulação de números complexos são as seguintes:

real(C) → Devolve a parte real de um número complexo C
imag(C) → Devolve a parte imaginária de um número complexo C
conj(C) → Devolve o conjugado de um número complexo C
angle(C) → Devolve a fase de um número complexo C
abs(C) → Devolve o módulo de um número complexo C
Exemplos:
>> imag(3+4i) >> real(3+4i) >> conj(3+4i) >> angle(3+4i) >> abs(3+4i)
ans = ans = ans = ans = ans =
4 3 3.0000 - 4.0000i 0.9273 5
7. Variáveis
As variáveis são representadas por identificadores compostos por cadeias de carateres
alfanuméricos e do caráter "_" (por ex: tempo, x, X). Os elementos de vetores e matrizes são
referenciados por índices (por ex: V(i), m(i,j)). As variáveis não são declaradas, apenas usadas
como parte de expressões. O Matlab é CaseSensitive, ou seja X e x são diferentes.
O Matlab trabalha fundamentalmente com um tipo de dados: matrizes de números reais ou
complexos. Casos especiais de matrizes são os escalares (matriz 1x1) e os vetores (matriz linha 1xm
e matriz coluna nx1). Uma variável pode ser utilizada para armazenar conjuntos de dados do
mesmo tipo, nas seguintes formas:
- um escalar (dimensão 1 x 1)
- um vetor coluna (dimensão n x 1),
- um vetor linha (dimensão 1 x m),
- uma matriz (dimensão n x m).
Escalar Vetor coluna Vetor linha Matriz
5 3 5 8 3 11 9 6 3
1x1 7 1X3 5 7 2
4 4 8 1
3X1 3x3
8. Variáveis predefinidas (constantes)

Uma variável predefinida, ou constante, é aquela em que o MatLab lhe atribui um valor inicial e
às quais se podem aplicar a generalidade das características das variáveis.
Algumas constantes em MatLab são as seguintes:
ans → Variável usada para guardar o valor da última operação efetuada
eps → Precisão do computador usado (diferença entre 1.0 e o valor real mais próximo)
pi → Valor de p = 3.141592654...
iej → representação de número imaginário (0 + 1.0000i = √-1)
-3-
Variáveis predefinidas (constantes)
inf → infinito (∞)

Nan → Significa que não é um número (not a number); por exemplo, 0/0
clock → Tempo corrente – vetor com ano, mês, dia, hora, minuto e segundo
date → Data atual – string no formato DD-MMM-AAAA (ex: 20-Apr-2016)
Exemplos:
tempo = clock; Tempo atual :
disp('Tempo atual : '); disp(tempo); 1.0e+003 *
2.0160 0.0040 0.0200 0.0190 0.0400 0.0503
Data = int16([tempo(3) tempo(2) tempo(1)]);
Data (dia mes ano):
Hora = int8([tempo(4) tempo(5) tempo(6)]); 20 4 2016
disp('Data (dia mes ano):'); disp(Data); Hora (hh mm ss):
disp('Hora (hh mm ss):'); disp(Hora); 19 40 50
No entanto, qualquer um destes identificadores pode ser redefinido pelo programador como
outra entidade (uma variável) e utilizado dessa forma.
Exemplo:
>> pi >> pi = 23 >> A = 2 * pi
ans = pi = A=
3.1416 23 46
9. Operadores e expressões
O MatLab é uma linguagem que aceite três tipos operadores e de expressões: aritméticos,
lógicos e de texto (literais).
9.1. Operadores e expressões aritméticas
Os operadores aritméticos são os seguintes:

- → Negação (operador unário)
+ → Adição
- → Subtração
* → Produto/multiplicação
/ → Divisão "por" (ex: 10/5 = 2)
\ → Divisão "para" (ex: 10\5 = 0.5 = 5/10)
rem/mod → Resto da divisão inteira (ex: 13/5 = 2; resto = 3)
^ → Potência (ex: 5^2 = 52 = 25)
Uma expressão aritmética pode ser criada utilizando:

- valores numéricos e/ou constantes,
- variáveis (desde que já criadas e com valores),
- funções aritméticas (predefinidas e/ou criadas pelo utilizador),
-4-
Operadores e expressões
- operadores,
- parêntesis,
- operador Ellipsis (...), que serve para continuar uma expressão noutra linha do texto.
Exemplo:
a = 10; resultado =
resultado = (pi + 5) * a + floor(23.87) ... 83.3326
/ 12
Regras de precedência dos operadores nas expressões:
1. () parêntesis
2. ^ potenciação
3. - sinal de negação (operador unário)
4. *, /, \ produto e divisões
5. +, - adição e subtração
Exemplos:
>> - (3 + 5) * 2 >> - 3 + 5 * 2
ans = ans =
-16 7
9.2. Expressões lógicas
Uma expressão lógica é aquela em que os operadores são lógicos e operandos são relações e/ou
variáveis do tipo lógico. O resultado de uma relação ou de uma expressão lógica é verdadeiro ou
falso; contudo, no MatLab o resultado é numérico: 1 significa verdadeiro e 0 falso.
Os operadores relacionais permitem relacionar entidades do mesmo tipo devolvendo 1 (true)
ou 0 (false) e são os seguintes:
> → Maior que
>= → Maior ou igual que
< → Menor que
<= → Menor ou igual que
== → Igual
~= → Diferente
Os operadores lógicos permitem a combinação ou negação das relações lógicas e são os
seguintes:
& → Conjunção (AND)
| → Disjunção (OR)
~ → Negação (NOT)
XOR → Disjunção binária exclusiva (XOR)
-5-
Operadores e expressões
Os operadores lógicos operam segundo a tabela seguinte:
A B AND OR XOR NOT (B)
1 1 1 1 0 0
1 0 0 1 1 1
0 1 0 1 1
0 0 0 0 0
10. Instrução de atribuição

Para atribuir um valor a uma variável, basta digitar o nome da variável, seguida pelo sinal de
atribuição (=), seguido pelo valor. Ou seja, a instrução de atribuição tem o seguinte formato:
<variável> = <expressão>
em que <variável> e <expressão> são do mesmo tipo (aritmética, lógica ou literal).
Exemplos:
X = 10, x = 2.3 + X;
angulo = cos(2 + x),
a = 10; t = 1 (t  verdadeiro);
w = (a == 5) & t (w = 0, pois (a == 5) é falso e, falso & falso = falso, ou seja, 0)
nome = ‘teste’, mensagem = 'matriz singular'
Uma variável, depois de usada, pode ser libertada (tornada não definida). Para tal, usa-se a
função clear, a qual tem a seguinte sintaxe:
clear ('<variável>')
Exemplo:
>> A = 25; >> clear('A');
>> A >> A
A=
??? Undefined function or variable 'A'.
25
11. Matrizes
11.1. Definir uma Matriz
Os elementos de cada linha são separados por espaços ou vírgulas. O final de cada linha é
indicado por um ponto-e-vírgula. A lista de elementos é delimitada por parêntesis retos [ ].
-6-
Matrizes
Exemplos:
% Matriz Bidimensional >> B = [16 3 2 13] % Vetor (Matriz Linha)
>> A = [16 3 2 13; 5 10 11 8; 9 6 7 12; 4 15 14 1] B=
A= 16 3 2 13
>> C = [16; 5; 9] % Vetor (Matriz Coluna)
16 3 2 13
C=
5 10 11 8
16
9 6 7 12
5
4 15 14 1 9
11.2. Aceder aos elementos de uma Matriz
Numa matriz bidimensional, A(i,j) é o elemento da i-ésima linha e j-ésima coluna. Num vetor,
B(k) é o k-ésimo elemento. O índice inicial da linha e da coluna de uma matriz, e de um vetor é 1.
Exemplos:
>> A = [16 3 2 13; 5 10 11 8; 9 6 7 12; 4 15 14 1]; >> B = [16 3 2 13];
>> A(2,3) >> B(2)
ans = ans =
11 3
11.3. Funções para criar uma Matriz
O Matlab possui funções que permitem a criação e manipulação de matrizes, como as seguintes:
zeros(m, n) → matriz de zeros de dimensão m x n (m linhas e n colunas)
ones(m, n) → matriz de uns de dimensão m x n
rand(m, n) → matriz (m x n) de números aleatórios com distribuição uniforme em ]0, 1[
randn(m, n) → matriz (m x n) de números aleatórios com distribuição normal (Gaussiana) de
média  = 0, variância d2 = 1 e desvio padrão d = 1
eye(m) → matriz identidade (matriz quadrada de ordem m)
Exemplos:
>> Z = zeros(2, 5) % matriz de dimensão 2 x 4 >> X = randn(2, 3)
Z= >> X = rand(2, 4) X=
0 0 0 0 0 X= -0.4326 0.1253 -1.1465
0 0 0 0 0 0.8214 0.6154 0.9218 0.1763 -1.6656 0.2877 1.1909
>> Q = ones(3, 5) 0.4447 0.7919 0.7382 0.4057 >> A = eye(3)
Q= % matriz quadrada de ordem 2 A=
1 1 1 1 1 >> X = rand(2) 1 0 0
1 1 1 1 1 X= 0 1 0
1 1 1 1 1 0.8913 0.4565 0 0 1
0.7621 0.0185
-7-
Matrizes
11.4. Concatenação de Matrizes
A concatenação de matrizes é feita da mesma maneira como é feita a definição de uma matriz.
Por exemplo, A = [B C; D E]; as matrizes B e C serão organizadas numa linha, enquanto que as
matrizes D e E serão organizadas noutra; o total de linhas de A será a soma do número de linhas de
B e D; o total de colunas de A será a soma do número de colunas de B e C.
Exemplo:
>> B = [1 30 7 ; 5 1 18; 1 4 10]; A=
>> C = [16 2 13; 5 10 8; 9 6 7 ]; 1 30 7 16 2 13
5 1 18 5 10 8
>> D = [16 3 13; 6 7 12; 4 14 1];
1 4 10 9 6 7
>> E = [5 11 8; 6 7 12; 4 15 1]; 16 3 13 5 11 8
>> A = [B C; D E] 6 7 12 6 7 12
4 14 1 4 15 1
11.5. Operadores aritméticos sobre matrizes
Os operadores aritméticos que se podem aplicar sobre uma matriz são os seguintes;
+ → soma termo a termo da matriz.
- → diferença termo a termo da matriz.
/ → produto da primeira matriz pela inversa da segunda; ou seja, as duas expressões
seguintes são equivalentes: C = A / B e C = A * inv(B);
./ → divisão termo a termo da matriz; para tal, as matrizes devem ter o mesmo tamanho.
* → produto matricial.
.* → multiplicação termo a termo das matrizes (devem ter o mesmo tamanho).
^ → produto matricial n vezes (ou seja, X^n = X * ... * X).
.^ → operação de potenciação termo a termo da matriz.
Exemplo (+):
>> A = [16 3 2 13; 5 10 11 8; 9 6 7 12; 4 15 14 1]; B=
>> B = A + A 32 6 4 26
10 20 22 16
18 12 14 24
8 30 28 2
Exemplo (-):
>> A = [16 3 2 13; 5 10 11 8; 9 6 7 12; 4 15 14 1]; B=
>> B = A - A' 0 -2 -7 9
2 0 5 -7
7 -5 0 -2
-9 7 2 0
-8-
Matrizes
Exemplo (/):
>> A = [16 3 2 13; 5 10 11 8; 9 6 7 12; 4 15 14 1]; B=
>> B = A / inv(A) 378.88 451.77 461.77 408.88
282.88 483.77 525.77 408.88
302.44 474.88 500.88 380.44
320.22 478.44 536.44 494.22
Exemplo (./):
>> A = [16 3 2 13; 5 10 11 8; 9 6 7 12; 4 15 14 1]; B=
>> B = A ./ A 1 1 1 1
1 1 1 1
1 1 1 1
1 1 1 1
Exemplo (*):
>> A = [16 3 2 13; 5 10 11 8; 9 6 7 12; 4 15 14 1]; B=
>> B = A * A 341 285 261 269
261 301 309 285
285 309 301 261
269 261 285 341
Exemplo (.*):
>> A = [16 3 2 13; 5 10 11 8; 9 6 7 12; 4 15 14 1]; B=
>> B = A .* A 256 9 4 169
25 100 121 64
81 36 49 144
16 225 196 1
Exemplo (^):
>> A = [16 3 2 13; 5 10 11 8; 9 6 7 12; 4 15 14 1]; B=
>> B = A ^ 2 341 285 261 269
261 301 309 285
285 309 301 261
269 261 285 341
Exemplo (.^):
>> A = [16 3 2 13; 5 10 11 8; 9 6 7 12; 4 15 14 1]; B=
>> B = A .^ 2 256 9 4 169
25 100 121 64
81 36 49 144
16 225 196 1
11.6. Operações com Matrizes
Algumas das operações que se podem realizar sobre uma matriz são as seguintes:
sum(M) → soma dos elementos de cada coluna da matriz M
’M → matriz transposta da matriz M
diag(M) → elementos da diagonal principal da matriz M
inv(M) → inversa da matriz M
-9-
Matrizes
size(M) → dimensão da matriz M

dot(M1, M2) → produto escalar da matriz M1 pela matriz M2
cross(M1, M2) → produto vetorial da matriz M1 pela matriz M2
trace(M) → traço da matriz M (soma dos elementos na diagonal principal)
det(M) → determinante da matriz M.
[A B] = eig(M) → A = vetores próprios da matriz M; B = valores próprios da matriz M
find(condição) → índices de uma matriz que satisfazem uma determinada condição;
função muito útil para selecionar elementos de uma matriz;
para determinar os resultados, a matriz é percorrida por colunas.
Exemplo:
>> A = [16 3 2 13; 5 10 11 8; 9 6 7 12; 4 15 14 1]; ans =
>> sum(A) 34 34 34 34
Exemplo:
>> A = [16 3 2 13; 5 10 11 8; 9 6 7 12; 4 15 14 1]; ans =
>> A' 16 5 9 4
3 10 6 15
2 11 7 14
13 8 12 1
Exemplo:
>> A = [16 3 2 13; 5 10 11 8; 9 6 7 12; 4 15 14 1]; ans =
>> diag(A) 16
10
7
1
Exemplo:
>> A = [16 3 2 13; 5 10 11 8; 9 6 7 12; 4 15 14 1]; ans =
>> inv(A) 1.0e+015 *
0.1251 0.3753 -0.3753 -0.1251
-0.3753 -1.1259 1.1259 0.3753
0.3753 1.1259 -1.1259 -0.3753
-0.1251 -0.3753 0.3753 0.1251
Exemplo:
>> A = [16 3 2 13; 5 10 11 8; 9 6 7 12; 4 15 14 1]; ans =
>> size(A) 4 4
Exemplo:
>> A = [16 3 2 13; 5 10 11 8; 9 6 7 12; 4 15 14 1]; ans =
>> dot(A, A) 378 370 370 378
- 10 -
Matrizes
Exemplo:
>> B = [1 2 3; 4 5 6;7 8 9]; ans =
>> cross(B, B) 0 0 0
0 0 0
0 0 0
Exemplo:
>> A = [16 3 2 13; 5 10 11 8; 9 6 7 12; 4 15 14 1]; ans =
>> trace(A) 34
Exemplo:
>> A = [16 3 2 13; 5 10 11 8; 9 6 7 12; 4 15 14 1]; ans =
>> det(A) 0
Exemplo:
>> A = [16 3 2 13; 5 10 11 8; 9 6 7 12; 4 15 14 1]; a=
>> [a b] = eig(A) -0.5000 -0.8165 0.2236 -0.4082
-0.5000 0.4082 -0.6708 -0.0000
-0.5000 0.0000 0.6708 -0.4082
-0.5000 0.4082 -0.2236 0.8165
b=
34.0000 0 0 0
0 8.0000 0 0
0 0 0.0000 0
0 0 0 -8.0000
Exemplo:
>> A = [16 3 2 13; 5 10 11 8; 9 6 7 12; 4 15 14 1]; a=
>> [a b] = find(A >= 5 & A < 10) 2
3
3
3
2
b=
1
1
2
3
4
Ou seja, são os seguintes elementos da matriz:
A(2,1) = 5; A(3,1) = 9; A(3,2) = 7; A(3,3) = 7; A(2,4) = 8.
Exemplo:
>> B = [16 3 2 13 5 10 11 8 9 6 7 12 4 15 14 1]; a=
1 2 3 13 14 16
>> a = find(B < 5 | B >= 15)
- 11 -
O operador ":"
12. O operador ":"
12.1. O operador ":" sobre Valores Numéricos

Trata-se de um poderoso operador do MatLab. Através dele é possível fazer a enumeração
intervalada de dados. Este operador permite selecionar um intervalo de valores com um
determinado espaçamento, podendo ser utilizado de 2 formas:
i:k:j
Lista os elementos de i a j, espaçados de k. Se k > 0, j > i; se k < 0, j < i.
i:j
Lista os elementos de i a j, espaçados de 1, onde j > i.
Exemplos:
>> 1:10 >> 60:-7:0
ans = ans =
1 2 3 4 5 6 7 8 9 10 60 53 46 39 32 25 18 11 4
>> 1:3:27 >> 0:pi/4:pi
ans = ans =
1 4 7 10 13 16 19 22 25 0 0.7854 1.5708 2.3562 3.1416
12.2. O operador ":" sobre Matrizes
O operador ":" é muito útil quando se deseja usar apenas uma parte da matriz. Por exemplo,
A(1:m, n) corresponde aos primeiros m elementos da n-ésima coluna
A(2:5, n) corresponde do 2º ao 5º elementos da n-ésima coluna
A(:, n) corresponde a todos os elementos da n-ésima coluna
A(:, end) corresponde a todos os elementos da última coluna
A(m, 1:n) corresponde os primeiros n elementos da m-ésima linha
A(m, :) corresponde a todos os elementos da m-ésima linha
A(end, :) corresponde a todos os elementos da última linha
A(:, [1 2 4]) corresponde às colunas 1, 2 e 4
12.3. O operador ":" para exclusão de Linhas ou Colunas
A exclusão de linhas e de colunas é feita definindo a linha ou a coluna a ser excluída como vazia.
Exemplo:
>> X = [16 3 2 13; 5 10 11 8; 9 6 7 12; 4 15 14 1]; X=
>> X(:,2) = [ ] 16 2 13
5 11 8
9 7 12
4 14 1
- 12 -
Funções matemáticas básicas
13. Funções matemáticas básicas

O MatLab disponibiliza várias funções matemáticas básicas, as quais se podem dividir em 4
classes: trigonométricas, exponenciais, numéricas e estatísticas.
13.1. Trigonométricas
As funções trigonométricas são as seguintes:

sin(x) → seno de x radianos
asin(x) → arco cujo seno é x (x real)
cos(x) → co-seno de x radianos
acos(x) → arco cujo cosseno é x (x real)
tan(x) → tangente de x radianos
atan(x) → arco cuja tangente é x (x real)
sec(x) → secante de x radianos
asec(x) → arco cuja secante é x (x real)
csc(x) → co-secante de x radianos
acsc(x) → arco cuja co-secante é x (x real)
cot(x) → co-tangente de x radianos
acot(x) → arco cuja co-tangente é x (x real)
13.2. Exponenciais
As funções exponenciais são as seguintes:

log(x) → logaritmo natural de x (base e), ln(x)
log10(x) → logaritmo de x na base 10, log10(x)
log2(x) → logaritmo de x na base 2, log2(x)
exp(x) → exponencial de x, ex
sqrt(x) → raiz quadrada de x
pow2(x) → 2 elevado à potência x, 2x
13.3. Numéricas
Algumas funções numéricas são as seguintes:

abs(x) → valor absoluto de x
ceil(x) → arredonda x na direção +∞
round(x) → arredonda x para inteiro mais próximo
floor(x) → arredonda x na direção -∞
fix(x) → arredonda x na direção de 0
lcm(x,y) → mínimo múltiplo comum entre x e y
- 13 -
Funções matemáticas básicas
gcd(x,y) → máximo divisor comum entre x e y

sign(x) → sinal de x (-1, se x < 0; 1, se x > 0; 0, se x = 0)
13.4. Estatísticas
Algumas funções estatísticas são as seguintes:

norm(X) → norma de X
fft(X) → transformada rápida de Fourier de um vetor X
ifft(X) → inversa da transformada rápida de Fourier de um vetor X
min(X) → menor elemento da matriz X
max(X) → maior elemento da matriz X
sort(X) → ordena os elementos da matriz X por ordem crescente
mean(X) → média de um vetor X
std(X) → desvio padrão de um vetor X
14. Funções
Deve-se tomar um certo cuidado com as funções do MatLab, pois esta linguagem possui funções
que podem retornar mais de um valor com uma única chamada (ao contrário das funções existentes
noutras linguagens que devolvem apenas um resultado).
14.1. Definição de uma função
De um modo geral, as funções no MatLab são definidas com a seguinte sintaxe:

function [<parâmetros_saída>] = <nome_função> (<parâmetros_entrada>);
<comandos>
em que function é uma palavra-chave que determina o início físico da função, <nome_função> é o
identificador, <parâmetros_entrada> é uma lista de parâmetros de entrada (separados por vírgulas)
necessários para o desenvolvimento do algoritmo afeto à função, <parâmetros_saída> especifica as
variáveis (separadas por vírgulas) que retornam os resultados da função (os parêntesis retos podem
ser omitidos se a existir apenas um parâmetro de saída), e <comandos> são as estruturas que
implementam os algoritmos.
Exemplo:
function [soma, produto] = soma_ produto (a, b);
soma = a + b;
produto = a * b;
É desejável que o nome da função seja igual ao nome do ficheiro onde está definida, mas sem
extensão. Para este exemplo, a função soma_ produto deve estar definida dentro do ficheiro
“soma_produto.m”. Se o ficheiro e a função tiverem nomes diferentes, então a chamada daquela
função é feita pelo nome do ficheiro (sem extensão) e não pelo nome da função.
- 14 -
Funções
Num ficheiro podem ser definidas mais do que uma função, mas a primeira delas deve ter o
mesmo nome do ficheiro. As restantes funções só podem ser chamadas pelas funções definidas
naquele ficheiro, não podendo ser chamadas por funções definidas noutros ficheiros.
As variáveis do programa são criadas no espaço de trabalho (globais). Nas funções as variáveis
são locais (não tendo acesso a variáveis globais e nem as podendo criar). Por sua vez, os parâmetros
de saída são variáveis globais.
14.2. Chamada de uma função
Uma função pode ser chamada incluída numa expressão (se devolve apenas um valor) ou usando
uma instrução de atribuição. Neste último caso, a sintaxe da chamada de uma função é a seguinte:
[<variáveis>] = <nome_função> (<parâmetros_entrada>)
em que <variáveis> é uma lista de variáveis (separadas por vírgulas ou espaços em branco) que
recebem os valores devolvidos pela função.
Exemplo:
>> [s p] = soma_produto(20, 10)
s=
30
p=
200
Quando se chama uma função que devolve mais do que um resultado, sem especificar as
variáveis que recebem os valores devolvidos pela função, apenas o primeiro resultado é conhecido.
Exemplos:
>> soma_produto(50, 20) >> a = 100 + soma_produto(30, 20)
ans = a=
70 150
15. Comandos de leitura/entrada e escrita/saída padrão
15.1. Comando de leitura
A leitura de dados pelo teclado pode ser feita com a função predefina input, a qual tem as
seguintes sintaxes:
[<variável>] = input ('mensagem') % para ler valores numéricos ou de texto
[<variável>] = input ('mensagem', 's') % para ler apenas valores de texto
em que mensagem é o texto a ser exibido ao utilizador (prompt), s para especificar que a entrada
do utilizador deve ser texto e <variável> para receber o valor numérico ou de texto inserido pelo
utilizador a partir do teclado (valor devolvido pela função input).
- 15 -
Comandos de leitura/entrada e escrita/saída padrão
Exemplos:
>> x = input('Insira o seu nome: ') >> st = input('Insira o seu nome: ', 's')
Insira um texto: 'Carlos' Insira o seu nome: Carlos
x= st =
Carlos Carlos
>> input('Insira um valor inteiro: ') >> st = input('Insira o seu nome: ', 's')
Insira um valor inteiro: 34 Insira o seu nome: 'Carlos'
ans = st =
34 'Carlos'
15.2. Comando de escrita
Para se mostrar/escrever os valores das variáveis dentro do programa, pode-se usar o comando
disp. Este comando tem a seguinte sintaxe:
disp ([var1, ..., varN])
em que var1, ..., varN devem ser do mesmo tipo (ou todos valores numéricos ou todos texto). As
vígulas podem ser substituídas por espaços em branco e os parentesis retos podem ser omitidos se
se pretende escrever apenas o valor de uma variável.
Exemplos:
>> m = 25; >> disp([m n]) >> disp([4, ' < ', 6])
>> n = 45; 25 45 #<#
>> disp([m, n]) >> disp(m) >> disp(['4', ' < ', '6'])
25 45 25 4<6
16. Estruturas condicionais

São comandos que controlam o fluxo e especificam a ordem em que a computação é feita. No
MatLab estes comandos são semelhantes aos usados na linguagem C, mas com uma estrutura
diferente. Também aqui existem dois tipos de estruturas condicionais: simples e composta.
16.1. Estrutura condicional simples
A estrutura simples é implementada com a estrutura "if-end" e tem a seguinte sintaxe:

if <condição>
<comandos>
end
em que if e end são palavras-chave; <condição> é uma expressão lógica; e <comandos> é uma lista
de comandos.
Se <condição> for verdadeira, então a lista <comandos> é executada; caso contrário, nenhum
comando é executado.
- 16 -
Estruturas condicionais
Exemplo:
programa: resultado da execução 1:
x = input('Insira um numero: '); Insira um numero: 20
if x > 0 20
disp(x); resultado da execução 2:
end; Insira um numero: -10
>>
16.2. Estrutura condicional composta
A estrutura composta é implementada pela estrutura "if-else-end" e tem a seguinte sintaxe:

if <condição>
<comandos1>
else
<comandos2>
end
em que if, else e end são palavras-chave; <condição> é uma expressão lógica; e <comandos1> e
<comandos1> são listas de comandos em que apenas uma delas é executada.
Se <condição1> for verdadeira, então a lista <comandos1> é executada; senão é executada a
lista <comandos2>.
Exemplo:
y = input('Insira outro numero: '); Insira outro numero: 50
if x < y 20
disp(x); resultado da execução 2:
else Insira um numero: 60
disp(y); Insira outro numero: 30
end; 30
16.3. Estrutura condicional composta com elseif
Quando é necessário implementar vários níveis de estruturas if-else, é preferível utilizar a

estrutura elseif.
Esta estrutura tem a seguinte sintaxe:
if <condição1>
<comandos1>
elseif <condição2>
<comandos2>
- 17 -
else
<comandos3>
end
em que if, else, elseif e end são palavras-chave, <condição1> e <condição2> são expressões lógicas,
e <comandos1>, <comandos2> e <comandos3> são listas de comandos em que apenas uma delas é
executada. A lista <comandos1> é executada se <condição1> for verdadeira; a lista <comandos2> é
executada se <condição1> for falsa e <condição2> verdadeira; e a lista <comandos3> é executada se
<condição1> e <condição2> form ambas falsas.
Exemplo:
if x > y Numero positivo!
disp('Numero positivo!');
resultado da execução 2:
elseif x == y
Insira um numero: -30
disp('Numero nulo!');
Numero negativo!
else
disp('Numero negativo!');
end;
16.4. Estrutura condicional alternativa
Esta estrutura, que é parecida com as anteriores, permite que se escolha uma opção entre várias
dependendo do resultado de uma variável ou expressão. A sua sintaxe é a seguinte:
switch <expressão>
case <opção1>
<comandos1>
...
case <opçãoN>
<comandosN>
otherwise
<comandos>
end
em que switch, case, otherwise e end são palavras-chave; <expressão> é uma expressão numérica
ou de texto; e <comandos1>, ..., <comandosN> e <comandos> são listas de comandos em que
apenas uma delas é executada.
Se o valor de <expressão> for igual ao valor de <opção1> então é executada a lista <comandos1>;
se não for, mas se o valor desta expressão for igual a <opção2> então é executada a lista
<comandos2>; e assim sucessivamente, até se verificar se o valor daquela expressão é igual a
- 18 -
<opçãoN> que, caso seja, executa a lista <comandosN>; se o valor da <expressão> não for igual a
nenhuma das opções, é executada a lista <comandos>. De referir que:  i, j, <opçãoi> ≠ <opçãoj>.
Exemplo 1:
switch x 2 30
case 1 resultado da execução 2:
y = 10; Insira um numero: 6
case 2 6 100
y = 30;
case 3
y = 50;
otherwise
y = 100;
end;
disp([x, y]);
Exemplo 2:
x = input('Insira um texto: ', 's'); Insira um numero: 200
switch x DUZENTOS
case '100' resultado da execução 2:
disp('CEM'); Insira um numero: 20
case '200' OUTRO
disp('DUZENTOS'); resultado da execução 3:
case '300' Insira um numero: 100
disp('TREZENTOS'); CEM
otherwise
disp('OUTRO');
end;
17. Estruturas de repetição

São estruturas que permitem que uma lista de ações seja executada várias vezes, isto é,
repetida. No MatLab estes comandos são semelhantes aos usados na linguagem C, mas com uma
estrutura diferente.
- 19 -
Estruturas de repetição
17.1. Estrutura "while"
A estrutura "while" testa uma condição lógica e executa uma lista de comandos enquanto a
condição for verdadeira. A sua sintaxe é a seguinte:
while <condição>
<comandos>
end
em que while e end são palavras-chave; e <comandos> é a lista de comandos que é executada
enquanto a <condição> for verdadeira.
Exemplo:
a=1 a=
1
b=4
b=
while a < b 4
a=
a=a+1
2
b=b-1 b=
3
end;
a=
3
b=
2
17.2. Estrutura "for"
A estrutura "for" é o controlador de fluxo usado quando o número de repetições está definido. A
sua sintaxe é a seguinte:
for <variável_controlo> = <valor_inicial> : <passo> : <valor_final>
<comandos>
end
em que for e end são palavras-chave e a variável <variável_controlo> assume todos os valores
desde <valor_inicial> até <valor_final> com intervalo de variação igual ao valor <passo>. Se o valor
<passo> não foi definido, ele assume o valor de 1.
Exemplo 1:
for i = 1:5 X
X(i)=i^2; 1 4 9 16 25
end;
disp('X'); disp(X);
- 20 -
Estruturas de repetição
Exemplo 2:
disp('k'); k=
for k = 0:5:15 0
disp(k); 5
end; 10
15
17.3. Os comandos continue e break
Os comandos continue e break servem para quebrar a continuidade de estruturas de repetição,

como o for e o while. No entanto, existe uma grande diferença entre esses dois comandos. O
comando continue interrompe a execução da estrutura de repetição e faz com que ela avance para
a sua próxima iteração, saltando a que estava a executar. O comando break interrompe a execução
da estrutura de repetição e termina-o, saltando para a primeira instrução fora daquela estrutura.
Exemplo:
k = 0; Insira um inteiro: 10
while k < 5 Insira um inteiro: 20
x = input('Insira um inteiro: '); Insira um inteiro: -10
if x > 0 Insira um inteiro: -20
k = k + 1; Insira um inteiro: 30
V(k) = x; Insira um inteiro: 0
elseif x < 0 k=
continue 3
else V=
break 10 20 30
end >>
end
k, V
18. O comando error

O comando error permite terminar a execução do algoritmo (programa ou função). Este
comando pode ser usado quando se verifica uma inconsistência, por exemplo, nos parâmetros de
entrada ou de uma operação que causaria uma operação inválida. A sua sintaxe é a seguinte:
error (mensagem)
em que error é uma palavra-chave e mensagem é o texto a apresentar no monitor antes de
abandonar o programa ou função.
- 21 -
Funções para manipular strings
19. Funções para manipular strings

Para o MatLab, uma string é com um vetor linha de caracteres. A maioria dos comandos vistos
até agora, como acesso a um elemento e seleção de elementos de uma matriz/vetor, são aplicáveis
no caso das strings.
Exemplo:
>> texto = 'Programando em MatLab.'; ans =
>> texto(16) M
Pode-se também selecionar uma substring de uma string
>> texto(16:21) ans =
MatLab
Apesar do MatLab ser um software voltado para cálculos matemáticos, possui diversas funções
para manipulação de strings. A seguir listam-se algumas destas funções.
findstrt
A sintaxe desta função é a seguinte:
<var_retorno> = findstr (<str1>, <str2>)
em que dadas duas strings, <str1> e <str2>, esta função verifica se a string de menor tamanho faz
parte da string de maior tamanho, devolvendo a posição do caráter inicial da string de menor
tamanho na string de maior tamanho. O identificador <var_retorno> é um argumento de saída
opcional que recebe o valor inteiro devolvido pela função. Esta função é Case-Sensitive.
Exemplo:
>> str1 = 'Programando em MatLab.' ; >> x = findstr(str1, str2)
>> str2 = 'MatLab'; x=
>> x = findstr(str2, str1) 16
x=
16
strcmp
A função strcmp compara duas strings e a sua sintaxe é a seguinte:
<var_retorno> = strcmp (<str1>, <str2>)
em que <str1> e <str2> são as duas strings a comparar, devolvendo 1 (se iguais) e 0 (se diferentes).
O identificador <var_retorno> é um argumento de saída opcional que recebe o valor inteiro
devolvido pela função. Esta função é Case-Sensitive.
Exemplo:
>> str1 = 'MATLAB'; x=
>> str2 = 'matlab'; 0
>> x = strcmp(str1, str2)
- 22 -
strcmpi
Função para comparar duas strings, mas não é Case-Sensitive. A sua sintaxe é a seguinte:
<var_retorno> = strcmpi (<str1>, <str2>)
em que <str1> e <str2> são as duas strings a comparar, devolvendo 1 (se iguais) e 0 (se diferentes).
O identificador <var_retorno> é um argumento de saída opcional que recebe o valor inteiro
devolvido pela função.
Exemplo:
>> str1 = 'MATLAB'; x=
>> str2 = 'matlab'; 1
>> x = strcmpi(str1, str2)
strtok
Esta função separa uma string em duas substrings e tem a seguinte sintaxe:
[<str1>, <str2>] = strtok (<str>, <separador>)
em que <str> é a string a ser separada, usando como separador o carater <separador>. Os
identificadores <str1> e <str2> são argumentos de saída que recebem as substrings determinadas.
Exemplo:
>> [str1, str2] = strtok('MatLab', 'L') str1 =
Mat
str2 =
Lab
strcat
Esta função determina a concatenação de N strings e a sua sintaxe é a seguinte:
<str> = strcat (<str1>, ..., <strN>)
em que <str> é a string resultante (e devolvida) com a concatenação de N strings. Na concatenação
de strings, os espaços em branco no fim das strings envolvidas são desprezados. O identificador
<str> é um argumento de saída opcional. Esta função é Case-Sensitive.
Exemplo:
>> st = strcat('Programar ', ' em ', ' MatLab. ')
st =
Programar em MatLab.
deblank
Esta função determina uma string resultante da remoção dos espaços em branco do final de uma
outra string, cuja sintaxe é a seguinte:
<strf> = deblank (<str>)
em que <strf> é a string definida à custa da remoção dos espaços em branco do final de uma string
fornecida como argumento, <str>. O identificador <strf> é um argumento de saída opcional que
recebe a string devolvida pela função.
- 23 -
sprintf
[<str>, <error>] = sprintf (<formato>, <valor>)
em que a string <str> é determinada a partir dos elementos de <valor> com um dado <formato>,
fornecidos como argumentos; <error> é um argumento de saída opcional que devolve uma
mensagem de erro, se ocorrer algum erro, ou uma matrz vazia, se não ocorrer qualquer erro.
A função sprintf é semelhante a fprintf, com a diferença que sprintf coloca os dados formatados
numa string e não num ficheiro (como fprintf faz).
Exemplo:
>> str = sprintf('%0d', 12) >> str = strcat('MatLab', '_', str)
str = str =
12 MatLab_12
sscanf
[<A>, <contador>, <error>, <seguinte>] = sscanf (<str>, <formato>, <tamanho>)
em que a função lê elementos da string <str>, converte-os de acordo com o <formato> especificado
e devolve o resultado numa matriz <A>.
Os identificadores <contador>, <error> e <seguinte> são argumentos de saída opcionais, em que
<contador> devolve o número de elementos lidos com sucesso, <error> devolve uma mensagem de
erro (se ocorrer erro) ou uma matriz vazia (se não ocorrer ero) e <seguinte> devolve um valor igual
ao número de carateres lidos em <str> mais uma unidade. O argumento de entrada <tamanho> é
opcional e especifica o número máximo de elementos que devem ser lidos da string <str> (se não
for especificado qualquer valor, serão lidos todos os elementos da string); os valores possíveis são:
N (ler no máximo N elementos para um vetor coluna), inf (ler pelo menos até ao fim da string),
[m, n] (ler no máximo m x n elementos preenchendo pelo menos uma matriz m x n por colunas).
A função sscanf é semelhante a fscanf, com a diferença que sscanf lê os dados formatados de
uma string e não de um ficheiro (como fscanf faz).
Exemplo:
>> [A, contador, error, seguinte] = sscanf('1 2 3 4 5 6 7 8 9', '%d', 5)
A=
1
2
3
4
5
- 24 -
contador =
5
error =
''
seguinte =
10
As funções sprintf e sscanf precisam de um parâmetro formato para especificar a forma como os
dados devem ser transformados durante a leitura ou a escrita. Entre os possíveis formatos estão:
%s : texto (string)
%d : decimal
%e : exponencial
%f : ponto fixo (quando usado com sprintf, pode-se definir número de casas; ex: %12.5f)
int2str
Esta função tem a seguinte sintaxe:
<str> = int2str (<numero_inteiro>)
Converte um número inteiro <numero_inteiro> numa string <str> (argumento de saída opcional).
num2str
<str> = num2str (<numero>)
Converte um número qualquer, <numero>, numa string <str> (argumento de saída opcional).
str2num
<var_retorno> = str2num (<str>)
Converte uma string, <str>, num número de qualquer tipo; <var_retorno> é um argumento de saída
opcional que recebe o número devolvido pela função.
strtoint
<var_retorno> = strtoint (<str>)
Converte uma string, <str>, num número inteiro; <var_retorno> é um argumento de saída opcional
que recebe o valor inteiro devolvido pela função.
str2double
<var_retorno> = str2double (<str>)
Converte uma string <str> num valor de dupla precisão; <var_retorno> é um argumento de saída
opcional que recebe o valor de dupla precisão devolvido pela função.
- 25 -
Comandos de leitura e escrita de dados formatadas em ficheiros
20. Comandos de leitura e escrita de dados formatadas em ficheiros

O MatLab possui diversas funções para leitura e escrita em ficheiros de texto e em ficheiros
binários. A seguir serão expostas as mais relevantes funções de leitura e de escrita, de modo a
abranger os dois tipos de ficheiros.
20.1. Abertura de um ficheiro
A função fopen abre um ficheiro com um determinado tipo de permissão e retorna um valor de
identificação do ficheiro para posterior manipulação. A sua sintaxe é a seguinte:
[<fid>, <mensagem>] = fopen (<nome_ficheiro>, <permissão>)
em que <fid> é variável que fica associada ao nome externo do ficheiro <nome_ficheiro> e que será
utilizada nos comandos de leitura e escrita no modo especificado pela <permissão>. Os valores
(opções) possíveis para <permissão> são os seguintes:
'r' : abre o ficheiro para leitura;
'w' : abre o ficheiro para escrita, criando o ficheiro, se não existe, ou removendo o seu
conteúdo, se já existe;
'r+' : abre o ficheiro para leitura e escrita, mas não cria o o ficheiro;
'w+' : abre o ficheiro para leitura e escrita, criando o ficheiro, se não existe, ou removendo o
seu conteúdo, se já existe;
'a' : cria e abre um ficheiro novo ou abre um ficheiro já existente para escrita, acrescentado no
fim do ficheiro;
'a+' : cria e abre um ficheiro novo ou abre um ficheiro já existente para leitura e escrita,
acrescentado no fim do ficheiro;
Para abrir um ficheiro de texto, ao valor da <permissão> deve ser acrescentado p caráter 't',
como por exemplo, 'wt' ou 'rt+'. Da mesma forma, para abrir um ficheiro binário, deve-se
acrescentar ao valor de <permissão> o caráter 'b', como por exemplo, 'rb' ou rb+'. Se <permissão>
for omitida, então será assumido o valor 'r'. Se não for especificado o tipo de ficheiro com um dos
carateres 't' ou 'b', assume-se que os ficheiros são binários.
Caso a função fopen tenha sucesso ao abrir o ficheiro, esta retornará o identificador de ficheiro
<fid> com um número inteiro maior do que 2 e o conteúdo de <mensagem> será vazio. O <fid> será
usado com outras funções de entrada e saída para identificar o ficheiro no qual as operações serão
realizadas. No entanto, se esta função não tiver sucesso, então <fid> = -1 e <mensagem> conterá
uma cadeia de carateres (string) informando o tipo de erro ocorrido.
- 26 -
Exemplo 1 (o ficheiro "entrada1.txt" não existe):

[f, erro] = fopen('entrada1.txt', 'r') f=
-1
erro =
Cannot open file. Existence? Permissions?
Memory? . . .
Exemplo 2 (o ficheiro "entrada.txt" existe):
[f, erro] = fopen('entrada.txt', 'r') f=
3
erro =
''
20.2. Fecho de um ficheiro
A função fclose fecha o ficheiro previamente aberto pela função fopen com base no seu número
de identifcação. A sua sintaxe é a seguinte:
[<variável>] = fclose (<fid>)
em que <fid> é a variiável que contém o identificador de um ficheiro aberto com fopen, e
<variável> recebe o valor que esta função retorna, que é 0, em caso de sucesso no fecho do
ficheiro, e -1, em caso de insucesso. Por outro lado, a chamada à função
fclose ('all')
fecha todos os ficheiros abertos com fopen.
Quando um ficheiro é fechado, a associação entre o identificador <fid> e o ficheiro físico
<nome_ficheiro> é desfeita.
20.3. Leitura de dados de um ficheiro
A função fscanf efetua a leitura de dados formatados de um ficheiro. A sua sintaxe é a seguinte:
[<variável>, <tamanho>] = fscanf (<fid>, <formato>, <elementos>)
em que <fid> é o identificador associado ao ficheiro onde se está a fazer a leitura dos dados
escritos no formato especificado por <formato> e atribuídos à <variável>. O argumento <tamanho>
é opcional e recebe o valor devolvido pela função que representa o número de elementos lidos com
sucesso; O argumento <elementos> é opcional e indica o limite para o número de valores a serem
lidos do ficheiro. O argumento <formato> pode assumir um dos seguintes valores:
%ni : usado para valores inteiros, sendo n o tamanho do campo de apresentação;
%n.df : notação na forma [-]888.88, sendo n o tamanho do campo (número total de carateres
apresentados) e d o número de dígitos decimais;
- 27 -
%n.de : notação na forma [-]8.888e88, sendo n o tamanho do campo (número total de

carateres apresentados) e d o número de dígitos decimais;
%n.dg : equivalete a %n.de ou %n.df, dependendo do formato mais curto; além disso, os zeros
insignificantes não são apresentados;
%ns : apresenta os carateres num campo de tamanho n.
Por sua vez, o argumento <elementos> pode assumir um dos seguintes valores:
n : lê até n valores num vetor coluna;
inf : lê até ao fim do ficheiro, resultando num vetor coluna contendo o mesmo número de
elementos do ficheiro;
[m, n] : lê os valores suficientes para preencher uma matriz de dimensão (m x n), preenchendo
esta matriz por coluna; n pode ser igual a inf mas não pode ser igual a m.
Aquando da leitura dos dados do ficheiro, o MatLab tentará combinar os dados do ficheiro com a
forma especificada em <formato>. Se a combinação ocorrer então os dados serão atribuídos por
coluna à <variável>. Se a combinação ocorrer apenas parcialmente, então apenas os dados
combinados com o <formato> serão atribuídos à variável e a operação de leitura será interrompida.
Exemplo:
[f, erro] = fopen('entrada.txt', 'r'); X=
if f == -1 1 4 7 10 13
error('Ficheiro nao aberto com sucesso'); 2 5 8 11 14
end; 3 6 9 12 15
[X, num] = fscanf(f, '%2i', [3, 5]); num =
fclose(f); 15
X
num
A função fgetl efetua a leitura de uma linha de texto de um ficheiro para uma string,
desprezando o carácter de quebra de linha (newline). A sua sintaxe é a seguinte:
[<variável>] = fgetl(<fid>)
em que <fid> é o identificador associado ao ficheiro onde se está a fazer a leitura da linha de
texto, a qual é atribuída à <variável> (do tipo string). Se for encontrado o indicador de fim do
ficheiro, é atribuído à <variável> o valor -1.
Por exemplo, o código seguinte lê cada uma das linhas do ficheiro "dados.txt", usando a função
fgetl, e coloca os dois números nela contidos (um inteiro e um real) numa estrutura com dois
campos (Numero e Nota), usando uma função para manipulação de strings (strtok).
- 28 -

f = fopen('dados.txt', 'r'); 23457 15.71
tam = 0; 34527 17.95
linha = fgetl(f); 45637 14.55
while linha ~= -1 24763 15.45
tam = tam + 1;
[num rem] = strtok(linha);
X(tam).Numero = str2num(num);
X(tam).Nota = str2num(rem);
linha = fgetl(f);
end;
fclose(f);
for i = 1:tam
fprintf('%8i %8.2f\n', X(i).Numero, X(i).Nota);
end;
A função fgets efetua a leitura de uma linha de texto de um ficheiro para uma string, incluindo o
carácter de quebra de linha (newline). A sua sintaxe apresenta duas forma, que são as seguintes:
[<variável>] = fgetl(<fid>)
[<variável>] = fgetl(<fid>, <nchar>)
em que <fid> é o identificador associado ao ficheiro onde se está a fazer a leitura da linha de
texto, a qual é atribuída à <variável> (do tipo string). No segundo caso, lê no máximo <nchar>
caracteres, continando a leitura no caracter seguinte. Se for encontrado o indicador de fim do
ficheiro, é atribuído à <variável> o valor -1.
A função textread lê os dados de um ficheiro e guarda-os em várias variévis, é um especificador

de formato semelhante ao da função fprintf que é utilizado para separar os dados de tipos distintos
em células distintas. A sua sintaxe tem as seguintes formas:
[<lista_variáveis>] = textread (<nome_ficheiro>, <formatos>, <N>)
em que <nome_ficheiro> é o nome do ficheiro donde se pretende ler os dados, os quais são
atribuídos à <lista_variáveis>, com os formatos especificados em <formatos>. Os valores possíveis
para o argumento <formatos> são os mesmos usados para o argumento <formato> da função fscanf.
O argumento <N> é um valor inteiro opcional que, quando positivo não nulo (> 0) significa que o
<formato> é reutilizado N vezes, e quando negativo que são lidos todos os dados do ficheiro.
Por exemplo, o código seguinte lê todos os dados do ficheiro "dados.txt", usando a função
textread, e coloca o primeiro e terceiro números de cada linha (um inteiro e um real) em dois
vetores (Numeros e Notas), desprezando o segundo número (um real).
- 29 -

f = fopen('dados.txt', 'r'); 23457 12.85
[Numeros Notas] = textread('dados.txt', '%d %*f %f'); 34527 16.12
fclose(f); 45637 18.64
tam = length(Numeros); 24763 14.76
for i = 1:tam
fprintf('%8i %8.2f\n', Numeros(i), Notas(i));
end;
20.4. Escrita de dados num ficheiro
A função fprintf permite guardar dados formatados num ficheiro que está numa unidade de
armazenamento externo. A sua sintaxe é a seguinte:
<tamanho> = fprintf (<fid>, <formatos>, <lista_variáveis>)
em que <tamanho> (opcional) recebe o número de bytes escritos, <fid> é o identificador associado
ao ficheiro onde se pretende guardar os dados, os quais estão contidos na <lista_variáveis>, com os
formatos especificados em <formatos>. Os valores possíveis para o argumento <formatos> são os
mesmos usados para o argumento <formato> da função fscanf. Se o argumento <fid> for omitido ou
se <fid> = 1, então os valores serão apresentados no monitor.
Exemplo 1:
[f, erro] = fopen ('saida1.txt', 'w'); num =
if f ~= -1 36
A = [16 3 2; 5 10 8; 9 6 7; 4 14 1];
num = fprintf(f, '%3i', A);
fclose(f);
num
end;
Exemplo 2:
[f, erro] = fopen('saida1.txt', 'w');
if f ~= -1
X1 = 10; X2 = 20; X3 = 30;
fprintf(f, '%7.4f %6.3f %5.2f\n', X1, X2, X3);
fclose(f);
end;
- 30 -
20.5. Verificar fim de um ficheiro de leitura
A função feof verifica se o último registo de um ficheiro, que foi aberto com fopen, foi lido (ou
seja, se já se atingiu o final do ficheiro). A sua sintaxe é a seguinte:
<variável_retorno> = feof (<fid>)
em que <fid> é o identificador do ficheiro em análise e <variável_retorno> recebe o valor 1, se foi
lido o último registo, ou 0, caso contrário.
21. Estruturas
Uma estrutura (struct) é um tipo de dados composto que permite armazenar dados de vários
tipos (os tipos básicos só permitem de um único tipo). Um estrutura é definida por um ou vários
campos (fields) de qualquer tipo de dados. Para se aceder aos campos de uma estrutura, utiliza-se
um ponto (.) depois do nome da variável, seguido pelo nome do campo, da seguinte forma:
variável.campo
Uma variável pode ser definida como uma estrutura de duas formas: a) usando instruções de
atribuição e b) usando a função struct.
21.1. Construção de uma estrutura usando instruções de atribuição
Pode-se definir uma variável simples como uma estrutura atribuindo individualmente valores aos
seus campos; o MatLab cria automaticamente a estrutura que se pretende. A sintaxe é a seguinte:
variável_estrutura.campo1 = valor1;
...
variável_estrutura.campoN = valorN;
Por exemplo, definir a variável aluno como uma estrutura com três campos: nome (vetor de
caracteres – string), numero (número inteiro) e testes (vetor de 3 reais = matriz de reais 1x3).
aluno.nome = 'Carlos Soares'; aluno =
aluno.numero = uint16(34127); nome: 'Carlos Soares'
aluno.testes = [14.5 16.7 15.6]; numero: 34127
aluno testes: [14.5000 16.7000 15.6000]
As estruturas podem ser vetores ou matrizes. Por exemplo, um vetor de alunos em que cada
aluno é uma estrutura com três campos: nome, numero e testes.
aluno(1).nome = 'Carlos Soares'; aluno =
aluno(1).numero = uint16(34127); 1x2 struct array with fields:
aluno(1).testes = [14.5 16.7 15.6]; nome
aluno(2).nome = 'Ana Sousa'; numero
aluno(2).numero = uint16(34925); testes
- 31 -
Estruturas
aluno(2).testes = [13.2 18.4 15.3]; Aluno 1:

aluno nome: 'Carlos Soares'
disp('Aluno 1:'); numero: 34127
disp(aluno(1)); testes: [14.5000 16.7000 15.6000]
disp('Aluno 2:'); Aluno 2:
disp(aluno(2)); nome: 'Ana Sousa'
numero: 34925
testes: [13.2000 18.4000 15.3000]
21.2. Construção de uma estrutura usando a função struct
A função struct pode ser usada de duas formas:

a) criar uma estrutura vazia defindo apenas os seus campos, cuja sintaxe é a seguinte:
variável_estrutura = struct (’campo1’, { }, ’campo2’, { }, ...)
em que variável_estrutura só pode ser definida como matriz ou vetor (não variável simples).
b) criar uma estrutura com os seus campos e respetivos valores, cuja sintaxe é a seguinte:
variável_estrutura = struct (’campo1’, valor1, ’campo2’, valor2, ...)
Exemplo 1: definir a variável aluno como uma estrutura com três campos (nome, numero e
testes), mas sem valores atribuídos aos seus campos (campos vazios).
aluno = struct ('nome', { }, 'numero', ... aluno =
{ }, 'testes', { }); 0x0 struct array with fields:
aluno nome
aluno(1).nome = 'Carlos Soares'; numero
aluno(1).numero = uint16(34127); testes
aluno(1).testes = [14.5 16.7 16.6]; Aluno 1:
disp('Aluno 1:'); nome: 'Carlos Soares'
disp(aluno(1)); numero: 34127
testes: [14.5000 16.7000 16.6000]
Exemplo 2: definir a variável aluno como uma estrutura com três campos (nome, numero e
testes), mas com valores atribuídos aos seus campos.
aluno = struct ('nome', 'Carlos Soares', ... aluno =
'numero', uint16(34127), ... nome: 'Carlos Soares'
'testes', [14.5 16.7 16.6]); numero: 34127
aluno testes: [14.5000 16.7000 16.6000]
aluno.nome = 'Ana Sousa'; aluno
- 32 -
Estruturas
aluno.numero = uint16(34925); nome: 'Ana Sousa'

aluno.testes = [13.2 18.4 15.3]; numero: 34925
aluno testes: [13.2000 18.4000 15.3000]
aluno(2).nome = 'Carlos Soares'; Aluno 1:
aluno(2).numero = uint16(34127); nome: 'Ana Sousa'
aluno(2).testes = [14.5 16.7 16.6]; numero: 34925
disp('Aluno 1:'); testes: [13.2000 18.4000 15.3000]
disp(aluno(1)); Aluno 2:
disp('Aluno 2:'); nome: 'Carlos Soares'
disp(aluno(2)); numero: 34127
testes: [14.5000 16.7000 16.6000]
21.3. Acesso aos dados das estruturas
Depois de construídas as estruturas, pode-se aceder aos elementos dos seus campos de várias
formas. Por exemplo, podem-se extrair várias estruturas de uma só vez.
Exemplo: partindo do exemplo anterior, criar um vector com todos os números de aluno (campo
numero):
aluno = struct ('nome', {}, 'numero', {}, 'testes', {}); Numeros =
aluno(1).nome = 'Carlos Soares'; 34127 34925
aluno(1).numero = uint16(34127);
aluno(1).testes = [14.5 16.7 16.6];
aluno(2).nome = 'Ana Sousa';
aluno(2).numero = uint16(34925);
aluno(2).testes = [13.2 18.4 15.3];
Numeros = [aluno.numero];
Numeros
21.4. Acrescentar campos a uma estrutura
Pode-se acrescentar um campo a uma estrutura adicionando esse novo campo à estrutura,
usando uma instrução de atribuição.
Exemplo: acrescenar o ano de nascimento do aluno (ssn) a um aluno (exemplo anterior):
aluno = struct ('nome', 'Carlos Soares', ... aluno =
'numero', uint16(34127), ... nome: 'Carlos Soares'
'testes', [14.5 16.7 16.6]); numero: 34127
aluno testes: [14.5000 16.7000 16.6000]
- 33 -
Estruturas
aluno.anoNasc = 1995; aluno =

aluno nome: 'Carlos Soares'
numero: 34127
testes: [14.5000 16.7000 16.6000]
anoNasc: 1995
21.5. Eliminar campos de uma estrutura
Para eliminar um campo de uma estrutura, utiliza-se a função rmfield. A sintaxe desta função é
a seguinte:
variável_estrutura_2 = rmfield (variável_estrutura_1, 'campo')
em que variável_estrutura_1 e variável_estrutura_2 podem ser a mesma e campo é o campo que se
pretende eliminar.
Exemplo:
aluno1.nome = 'Ana Sousa'; aluno1 =
aluno1.numero = uint16(34925); nome: 'Ana Sousa'
aluno1.testes = [13.2 18.4 15.3]; numero: 34925
aluno1 testes: [13.2000 18.4000 15.3000]
aluno2 = rmfield(aluno1, 'numero'); aluno2 =
aluno2 nome: 'Ana Sousa'
aluno1 = rmfield(aluno1, 'nome'); testes: [13.2000 18.4000 15.3000]
aluno1 aluno1 =
numero: 34925
testes: [13.2000 18.4000 15.3000]
21.6. Matriz de células (cells array)
Tal como uma estrutura, uma matrize de células é um tipo de dados composto que permitem
armazenar dados de vários tipos (e não apenas de um só tipo, como acontece com os tipos de dados
básicos). As células são armazenadas de forma semelhante às matrizes numéricas.
Por exemplo, uma matriz de células pode conter numa célula uma matriz de reais, numa outra
uma matriz de inteiros, numa outra um vetor de strings, numa outra uma matriz de números
complexos, numa outra uma estrutura, numa outra uma matriz de células, etc.
Cell 1,1 Cell 1,2 Cell 1,3
1.6 2.3 3.0 'Carlos Antunes' 2.5 + 3 i 5–8i

6.0 5.1 4.3 'Covilha' 26 + 5 i 7 + 0.5 i
7.8 8.2 9.5 '24-06-2016'
- 34 -
Estruturas
Cell 2,1 Cell 2,2 Cell 2,3

[ 2.54 8.65 5.43 ] 12 43 58
2 5
8 76 25 'Texto'
7 3
39 7 3
[2 5 8] 2.5 + 6.5 i
21.6.1. Criar uma matriz de células

Uma matriz de células pode ser criada usando instruções de atribuição ou usando a função cell
para alocar previamente a matriz (as células da matriz ficam vazias) e posteriormente atribuir
dados às suas células.
a) Criar uma célula de cada vez usando instruções de atribuição

Pode-se construir uma matriz de células atribuindo dados às suas células individualmente e uma
de cada vez, usando instruções de atribuição. Assim, o MatLab define automaticamente a matriz
pretendida. Existem duas formas de atribuir dados às célula usando instruções de atribuiçãos: por
indexação das células ou por indexação dos conteúdos.
No caso por indexação das células, os índices das células são delimitados por parêntesis curvos,
"()", usando a notação padrão das matrizes. Os conteúdos das células da parte direita das instruções
de atribuição são delimitados por chavetas, "{ }".
- 35 -
Estruturas
Exemplo: criar uma matriz de células A de dimensão 2x2

A(1,1) = {[1 4 3; 0 5 8; 7 2 9]}; A=
A(1,2) = {'Carlos Antunes'}; [3x3 double] 'Carlos Antunes'
A(2,1) = {3 + 7i}; [3.0000+ 7.0000i] [1x5 double]
A(2,2) = {10:10:50}; A{1,1} =
A 1 4 3
celldisp(A); 0 5 8
7 2 9
A{2,1} =
3.0000 + 7.0000
A{1,2} =
Carlos Antunes
A{2,2} =
10 20 30 40 50
No caso por indexação do conteúdo, os índices das matrizes são delimitados por chavetas, "{}",
usando a notação padrão de matrizes. Os conteúdos das células são especificadas na parte direita
da instrução de atribuição de forma normal (sem chavetas).
Exemplo: criar uma matriz de células A de dimensão 2x2 (igual ao anterior)
B{1,1} = [1 4 3; 0 5 8; 7 2 9]; B=
B{1,2} = 'Carlos Antunes'; [3x3 double] 'Carlos Antunes'
B{2,1} = 3 + 7i; [3.0000+ 7.0000i] [1x5 double]
B{2,2} = 10:10:50; B{1,1} =
B 1 4 3
celldisp(B); 0 5 8
7 2 9
B{2,1} =
3.0000 + 7.0000i
B{1,2} =
Carlos Antunes
B{2,2} =
10 20 30 40 50
Nota: A função celldisp (semelhante à função disp) mostra o conteúdo de cada célula da matriz de
céluas. Por sua vez, a função cellplot mostra a arquitetura das células graficamente.
- 36 -
Estruturas
Ao atribuir-se dados a uma célula de uma matriz de células com índices fora das dimensões
daquela matriz, o MatLab expande e ajusta automaticamente a matriz de forma a incluir aqueles
índices na sua nova dimensão; por sua vez, as restantes novas células são preenchidas com o vazio.
Exemplos: transformar a matriz 2x2 do exemplo anterior numa matriz de 3x3 e de 3x2.
Exemplo 1: Exemplo 2:
>> B{3,3} = 5 >> B{3,2} = 5
B= B=
[3x3 double] 'Carlos Antunes' [] [3x3 double] 'Carlos Antunes'
[3.000+ 7.000i] [1x5 double] [] [3.0000+ 7.0000i] [1x5 double]
[] [] [5] [] [ 5]
b) Criar toda matriz usando uma instrução de atribuição

Também se pode criar uma matriz de células com uma só instrução de atribuiçao (isto é, sem
especificar explicitamente os índices da matriz), usando chavetas. Desta forma, as chavetas, "{ }",
são construtores de matrizes de células, tal como os parêntesis retos são construtores de matrizes
numéricas. Entre as chavetas usa-se vígulas ou espaços em branco para indicar quebras de coluna e
pontos e vírgula para indicar quebras de linha entre células.
Exemplo:
>> C = {[1 2], [3 4]; [5 6], [7 8]} >> celldisp(C);
C= C{1,1} =
[1x2 double] [1x2 double] 1 2
C{2,1} =
[1x2 double] [1x2 double]
5 6
C{1,2} =
3 4
C{2,2} =
7 8
c) Criar toda matriz usando a função cell

A função cell permite alocar previamente uma matriz de células da dimensão especificada e com
todas as suas células vazias. A sintaxe desta função tem as seguintes formas:
c = cell(n)
Cria uma matriz quadrada de ordem n, em que n é um escalar (se não for, surge um erro).
Exemplo:
>> A = cell(2) >> A = cell(T)
A= ??? Undefined function or variable 'T'.
[] [] >> A = cell('2')
[] [] ??? Error using ==> cell
Conversion to cell from char is not possible.
- 37 -
Estruturas
c = cell(m,n) ou c = cell([m n])

Cria uma matriz de m linhas e n colunas (m x n), em que m e n são escalares.
Exemplo:
>> B = cell([2 5])
B=
[] [] [] [] []
[] [] [] [] []
c = cell(m,n,p,...) ou c = cell([m n p ...])
Cria uma matriz de várias dimensões (m x n x p x ...) vazia, em que m, n, p, ... são escalares.
c = cell(size(A))
Cria uma matriz vazia com a mesma dimensão de A
Depois da matriz de células ser alocada, as suas células podem ser preenchidas individualmente,
usando instruções de atribuição.
Exemplo (criar uma matriz de células 2x3 vazia e preencher algumas delas):
B = cell(2,3); B=
B = cell(2,3); [1x3 double] [] 'celula 1,3'
B(1,1) = {1:3}; [] [2x2 double] []
B{1,3} = 'celula 1,3'; B{1,1} =
B(2,2) = {[1 2; 3 4]}; 1 2 3
B B{2,1} =
celldisp(B); []
B{1,2} =
[]
B{2,2} =
1 2
3 4
B{1,3} =
celula 1,3
B{2,3} =
[]
21.7. Ober dados de uma matriz de células
Pode-se obter dados de de uma matriz de células e armazená-los numa matriz simples ou numa
nova célula de uma outra matriz. Isto pode ser feito com instruções de atribuição de duas formas:
a) acedendo aos conteúdos das células usando indexação de conteúdos, ou
b) acedendo a um subconjunto de células usando indexação de células.
- 38 -
Estruturas
a) Aceder ao conteúdo de uma célula usando indexação de conteúdos

Pode-se usar indexação de conteúdos na parte direita de uma instrução de atribuição para
aceder a algum ou a todos os dados de uma qualquer célula e indicando a variável que recebe os
dados na parte esquerda da instrução de atribuição. Os índices da matriz de células são
referenciados entre chavetas, para indicar que se está a atribuir o conteúdo das células e não as
próprias células.
Exemplo:
A{1,1} = [1 4 3; 0 5 8; 7 2 9]; X=
A{1,2} = 'Carlos Antunes'; 1 4 3
A{2,1} = 3 + 7i; 0 5 8
A{2,2} = 10:10:50; 7 2 9
X = A{1,1} V=
V = A{1,1}(2,2) 5
Nas atribuições, deve-se indicar explicitamente os índices de uma única célula e não de um
subconjunto de células. Por exemplo, as atribuições A[1,:] = valor e B = A[1,:] são ambas invalidas.
b) Aceder a um subconjunto de células usando indexação de células

Usar a indexação de células para atribuir um qualquer conjunto de células a uma outra variável,
criando uma nova matriz de células. Para tal, deve-se usar a vírgula para aceder aos subconjuntos
de células dentro da matriz de células.
Exemplo:
A{1,1} = [1 4 3; 0 5 8; 7 2 9]; B=
A{1,2} = 'Carlos Antunes'; [3.0000+ 7.0000i] [1x5 double]
A{2,1} = 3 + 7i; B{1} =
A{2,2} = 10:10:50; 3.0000 + 7.0000i
B = A(2, 1:2) B{2} =
celldisp(B) 10 20 30 40 50
21.7.1. Eliminando células

Pode-se eliminar uma dimensão completa da matriz de células (linha ou coluna) tal como
acontece com uma matriz normal. Para tal, basta indicar a linha ou a coluna que se pretende
eliminar, colocando o índice entre parêntesis, e atribuir-lhe o vazio, da seguinte forma:
A(indice_linha, :) = [] (eliminar uma linha)
A(:, indice_coluna) = [] (eliminar uma coluna)
- 39 -
Estruturas
Exemplo:
A{1,1} = [1 4 3; 0 5 8; 7 2 9]; A=
A{1,2} = 'Carlos Antunes'; [3x3 double] 'Carlos Antunes'
A{2,1} = 3 + 7i; [3.0000+ 7.0000i] [1x5 double]
A{2,2} = 10:10:50; A=
B = A; [3.0000+ 7.0000i] [1x5 double]
A B=
A(1, :) = []; [3x3 double]
A [3.0000+ 7.0000i]
B(:, 2) = [];
B
21.7.2. Remodelação de uma matriz de células
Tal como outros tipos de matrizes, pode-se remodelar uma matriz de células usando a função
reshape. O número de células mantém-se o mesmo, alterando apenas a sua disposição pelo nova
matriz após remodelação; não se usa a função reshape para adicionar ou remover células.
Exemplo:
A{1,1} = [1 4 3; 0 5 8; 7 2 9]; A=
A{1,2} = 'Carlos Antunes'; [3x3 double] 'Carlos Antunes'
A{2,1} = 3 + 7i; [3.0000+ 7.0000i] [1x5 double]
A{2,2} = 10:10:50; B=
A [3x3 double] [3.0000+ 7.0000i] 'Carlos Antunes' [1x5 double]
B = reshape(A,1,4); C=
B [3x3 double]
C = reshape(A,4,1); [3.0000+ 7.0000i]
C 'Carlos Antunes'
A = reshape(A,1,4); [1x5 double]
A A=
[3x3 double] [3.0000+ 7.0000i] 'Carlos Antunes' [1x5 double]
21.7.3. Matrizes de células de estruturas
As matrizes de células podem armazenar grupos de estruturas com diferentes arquiteturas, em

que cada arquitetura é composta por vários campos.
O exemplo que se segue consiste em criar uma matriz de células com duas células (1 x 2), ou um
vetor com duas células, em que cada uma delas contém uma estrutura diferentes entre si.
- 40 -
Estruturas
Exemplo:
A = cell(1,2); A=
A{1}.numero = int32(34216); [1x1 struct] [1x1 struct]
A{1}.nome = 'Carlos Antunes'; A{1} =
A{2}.trabalhos = [0.7 0.5 1.0 0.3 0.5]; numero: 34216
A{2}.frequencia = 8.5; nome: 'Carlos Antunes'
A{2}.exame = 10.7; A{2} =
A{2}.final = []; trabalhos: [0.7000 0.5000 1 0.3000 0.5000]
A frequencia: 8.5000
celldisp(A); exame: 10.7000
final: []
A célula 1 do vetor A contém uma estrutura com dois campos: um número inteiro e uma string. A
célula 2 de A contém uma estrutura com três campos: um vetor de reais e dois números reais.
Após a construção de uma matriz de células com estruturas, pode-se aceder aos conteúdos das
suas células usando indexação dos conteúdos. A sua sintaxe é a seguinte:
<matriz_celulas>{indice_celula}.campo
Por exemplo, depois de se construir a matriz de células A (exemlo anterior), para se determinar a
nota final (campo final da célula 2), deve-se aceder a toda a celula 2, tal como apresentado no
exemplo seguinte:
notaT = 0; A{1} =
for i = 1:5 numero: 34216
notaT = notaT + A{2}.trabalhos(i); nome: 'Carlos Antunes'
end; A{2} =
if A{2}.frequencia > A{2}.exame trabalhos: [0.7000 0.5000 1 0.3000 0.5000]
A{2}.final = notaT + A{2}.frequencia; frequencia: 8.5000
else exame: 10.7000
A{2}.final = notaT + A{2}.exame; final: 13.7000
end;
celldisp(A);
- 41 -
Funções gráficas
22. Funções gráficas
22.1. Desenho de curvas
A função plot serve para desenhar um gráfico bidimensional. Para desenhar um gráfico
tridimensional, utiliza-se a função plot3.
Para se desenhar uma curva bidimensional são necessários duas sequências de valores, uma para
o eixo das abcissas (eixo dos XX) e outra para o eixo das ordenadas (eixo dos YY). Para tal, estas
sequências de valores podem ser armazenadas em vetores ou em matrizes.
22.1.1. Utilização com vetores
Quando se usam vetores, a função plot pode ser usada com as seguintes formas:
plot (Y)
Se Y é um vetor com N elementos, desenha uma curva em que os valores para o eixo das abcissas
são os índices do vetor (1, 2, ..., N) e os valores para o eixo das ordenadas são os elementos do
vetor Y. Desta forma, os N pontos considerados no gráfico são: (1, Y(1)), ...(N, Y(N)).
plot (X, Y)
Se X e Y são vetores com N elementos, desenha uma curva em que os valores para o eixo das
abcissas são os elementos do vetor X e os valores para o eixo das ordenadas são os elementos do
vetor Y. Assim, os N pontos considerados no gráfico são: (X(1), Y(1)), ...(X(N), Y(N)).
plot (X1,Y1, X2, Y2, ..., Xn, Yn)
Desenha n curvas tal que para a k-ésima curva os valores para o eixo das abcissas são os
elementos do vetor Xk (Xk(1), ..., Xk(N)) e os valores para o eixo das ordenadas são os elementos
do vetor Yk (Yk(1), ..., Yk(N)). Ou seja, é como aplicar a função plot n vezes sobre o mesmo
gráfco: plot(X1, Y1), ..., plot(Xn, Yn).
22.1.2. Utilização com matrizes

Quando se usam matrizes, a função plot pode ser usada com as seguintes formas:
plot (Y)
Se Y é uma mariz de m x n, desenha n curvas em que os valores para o eixo das abcissas são os
índices das linhas da matriz (1, 2, ..., m) e os valores para o eixo das ordenadas são os
elementos das colunas da matriz Y. Desta forma, para a k-ésima curva são usados os valores da
coluna k da matriz Y (Y(1,k), ..., Y(m,k)); ou seja, os pontos envolvidos nesta curva são os
seguintes: (1, Y(1,k)), ..., (m, Y(m,k)).
plot (X, Y)
Se X é um vetor com m elementos e Y uma matriz de m x n, desenha n curvas em que os valores
para o eixo das abcissas são os os elementos do vetor X e os valores para o eixo das ordenadas
são os elementos das colunas da matriz Y. Desta forma, para a k-ésima curva são usados os
- 42 -
Funções gráficas
valores do vetor X e os valores da coluna k da matriz Y (Y(1,k), ..., Y(m,k)); ou seja, os pontos
envolvidos nesta curva são os seguintes: (X(1), Y(1,k)), ..., (X(m), Y(m,k)).
Se X é um vetor com n elementos e Y uma matriz de m x n, desenha m curvas em que os valores
para o eixo das abcissas são os os elementos do vetor X e os valores para o eixo das ordenadas
são os elementos das linhas da matriz Y. Ou seja, os pontos envolvidos nesta curva são os
seguintes: (X(1), Y(k,1)), ..., (X(n), Y(k,n)).
plot (X1,Y1, X2, Y2, ..., Xn, Yn)
Se X e Y são matrizes de m x n, desenha n curvas em que para a k-ésima curva os valores para o
eixo das abcissas são as colunas da matriz X e para o eixo das ordenadas são as colunas da matriz
de Y. Ou seja, é como aplicar n vezes a função plot sobre o mesmo gráfco: plot(X1, Y1), ...,
plot(Xn, Yn).
A função plot3, para desenhar gráficos tridimensionais, funciona de forma semelhante à função
plot, com a diferença que plot3 utiliza 3 parâmetros de dados.
22.2. Estilos de Linhas e Cores na função plot e plot3
Para além do parâmetro referente aos dados a serem apresentados no gráfico, essas funções
possuem um outro parâmetro referente à cor e ao tipo de traço/linha. Desta forma, a sintaxe da
função plot é a seguinte:
plot (X, Y, config)
em que config é um conjunto de símbolos que permitem alterar o estilo do gráfico. Estes símbolos
estão associados à cor, ao marcador e ao tipo de linha a apresentar no gráfico. Se este parâmetro
não for utilizado, a função plot assume a configuração padrão: linha azul e continua.
As cores possíveis são as seguintes (símbolo): amarelo (y), lilás (m), azul claro (c), vermelho (r),
verde (g), azul escuro (b), branco (w) e preto (k).
Os marcadores possíveis são os seguintes (símbolo): ponto (.), estrela (*), círculo (º), + (+), x (x),
quadrado (s), losango (d), triângulo para baixo (v), triângulo para cima (^), triângulo para a
esquerda (<), triângulo para a direita (>), pentagrama (p) e hexagrama (h).
Os tipos de linha possíveis são os seguintes (símbolo): linha contínua (-), linha tracejada (--),
traços e pontos (-.) e linha pontilhada (:).
Exemplo:
>> X = 0:0.05:1;
>> plot(X, X.^2, 'bd--');
X= 0 0.0500 0.1000 0.1500 0.2000 ... 0.8500 0.9000 0.9500 1.0000
X.^2 = 0 0.0025 0.0100 0.0225 0.0400 ... 0.7225 0.8100 0.9025 1.0000
- 43 -
Funções gráficas
22.3. Desenho de superfícies
O MatLab possui várias funções para o desenho de superfícies. Entre elas pode-se destacar os
seguintes: mesh, surf, contour e contour3. Qualquer uma destas funções desenha uma superfície
cujos dados estão contidos numa matriz. Estas funções têm duas formas :
G(Z) - a superfície será desenhada sem nenhuma informação referente aos eixos X e Y;
G(X, Y, Z) - a superficie será desenhada levando em consideraçãoo o dominio de X e Y;
em que G refere-se a uma qualquer das funções mesh, surf, contour e contour3.
Para se usar estas funções, deve-se começar por definir um espaço de coordenadas onde se
aplicar estas funções, o que é feito usando a função meshgrid.
22.3.1. Função meshgrid

[X, Y] = meshgrid (minX:intervaloX:maxX, minY:intervaloY:maxY)
que constrói a matriz X a partir do dominio especificado por minX:intervaloX:maxX e a matriz Y a
partir do dominio especificado por minY:intervaloY:maxY, as quais podem ser usadas para calcular
os valores das funções de 2 variáveis e desenho de superfícies a 3D. A matriz X é construída por
linhas e a matriz Y por colunas. Esta função pode também ser usada das seguintes formas:
[X, Y] = meshgrid (min:intervalo:max)
que é o mesmo que [X, Y] = meshgrid (min:intervalo:max, min:intervalo:max) e
[X, Y, Z] = meshgrid (minX:intervaloX:maxX, minY:intervaloY:maxY, minZ:intervaloZ:maxZ)
que cria um array tridimensional que pode ser usado para calcular o valor de funçõs com 3 variáveis
e desenhar gráficos volumétricos a 3D.
- 44 -
Funções gráficas
Exemplo: calcular as matrizes X e Y para o domínio [-2, 2] x [-2, 2]

>> [X, Y] = meshgrid(-2:0.8:2, -2:0.8:2);
>> X
X=
-2.0000 -1.2000 -0.4000 0.4000 1.2000 2.0000
-2.0000 -1.2000 -0.4000 0.4000 1.2000 2.0000
-2.0000 -1.2000 -0.4000 0.4000 1.2000 2.0000
-2.0000 -1.2000 -0.4000 0.4000 1.2000 2.0000
-2.0000 -1.2000 -0.4000 0.4000 1.2000 2.0000
-2.0000 -1.2000 -0.4000 0.4000 1.2000 2.0000
>> Y
Y=
-2.0000 -2.0000 -2.0000 -2.0000 -2.0000 -2.0000
-1.2000 -1.2000 -1.2000 -1.2000 -1.2000 -1.2000
-0.4000 -0.4000 -0.4000 -0.4000 -0.4000 -0.4000
0.4000 0.4000 0.4000 0.4000 0.4000 0.4000
1.2000 1.2000 1.2000 1.2000 1.2000 1.2000
2.0000 2.0000 2.0000 2.0000 2.0000 2.0000
>> [X, Y] = meshgrid(-2:1:2, -2:1:2);
>> X
X=
-2 -1 0 1 2
-2 -1 0 1 2
-2 -1 0 1 2
-2 -1 0 1 2
-2 -1 0 1 2
>> Y
Y=
-2 -2 -2 -2 -2
-1 -1 -1 -1 -1
0 0 0 0 0
1 1 1 1 1
2 2 2 2 2
- 45 -
Funções gráficas
22.3.2. Função mesh

A função mesh desenha uma malha a 3D não preenchida.
Exemplo: calcular para função x * exp(-x2 – y2) no domínio [-2, 2] x [-2, 2]
>> [X, Y] = meshgrid(-2:0.2:2, -2:0.2:2); % x, y  [-2, 2] x [-2, 2] com intervalo de 0.2
>> Z = X .* exp(-X.^2 - Y.^2);
>> mesh(Z); >> mesh(X, Y, Z);
22.3.3. Função surf

A função surf desenha uma superfície a 3D preenchida.
>> Z = X .* exp(-X.^2 - Y.^2);
>> surf(Z); >> surf(X, Y, Z);
- 46 -
Funções gráficas
22.3.4. Função contour

A função contour desenha um conjunto de curvas de nível num plano.
>> Z = X .* exp(-X.^2 - Y.^2);
>> contour(Z, 6) >> contour(X, Y, Z, 6)
22.3.5. Função contour3
A função contour3 desenha um conjunto de curvas de nível num espaço tridimensional.

>> Z = X .* exp(-X.^2 – Y.^2);
>> contour3(Z, 6) >> contour3(X, Y, Z, 6)
- 47 -
Funções gráficas
22.4. Desenhar barra de cores
A função colorbar permite desenhar uma barra de cores num gráfico. Esta barra representa a
variação dos valores do gráfico.
>> Z = X .* exp(-X.^2 – Y.^2);
>> mesh(Z), colorbar;
22.5. Inserir anotações num gráfico
O Matlab possui várias funções para escrever em gráficos, sendo algumas delas as que a seguir se
apresentam.
title(‘titulo’) - coloca o título “titulo” na posição acima do gráfico;
grid on/off - grid on mostra uma grelha na janela do gráfico e grid off apaga a grelha;
xlabel(‘nome do eixo X’) - coloca um nome para o eixo X do gráfico;
ylabel(‘nome do eixo Y’) - coloca um nome para o eixo Y do gráfico;
zlabel(‘nome do eixo Z’) - coloca um nome para o eixo Z do gráfico;
axis on/off - axis on desenha os eixos coordenados e axis off apaga os eixos;
axis([xmin xmax ymin ymax zmin zmax]) - ajusta os limites das coordenadas da janela onde
está o gráfico: X variando de xmin a xmax, e o mesmo para Y e Z;
text(X,Y,’texto’) - coloca um texto na posição (X,Y) de um gráfico bidimensional;
text(X,Y,Z,’texto’) - coloca um texto na posição (X,Y) de um gráfico tridimensional.
Obs: Esses comandos podem ser utilizados tanto para desenho de gráficos como de superfícies.
- 48 -
Funções gráficas
22.6. Criar novas janelas para gráficos
A função figure permite criar uma nova janela para a apresentação de gráficos. Sem esta função,
todos os gráficos serão desenhados na mesma janela, sendo que um novo gráfico sobrepõe o último
que foi desenhado.
Exemplo: desenhar os gráficos dos vetores x e y em duas janelas diferentes.
>> X = -10:1:10;
>> figure(1);
>> plot(X, X.^2);
>> figure(2);
>> plot(X, X.^3);
22.7. Mostrar vários gráficos na mesma janela
A função subplot permite mostrar vários gráficos numa mesma janela. A sua sintaxe é a seguinte:
subplot(r, c, p)
em que r x c indica o número de posições possíveis em que os gráficos podem ser apresentados, e a
sua disposição (em r linhas e c colunas), e p é um número em { 1, ..., r x c } que representa a
posição selecionada.
Exemplo:
>> x = 0:pi/8:pi;
>> subplot(2, 3, 2);
>> plot(x, cos(x));
>> title('Coseno');
- 49 -
Funções gráficas
>> subplot(2, 3, 4);

>> plot(x, sin(x));
>> title('Seno');
>> subplot(2, 3, 6);
>> plot(x, tan(x));
>> title('Tangente');
- 50 -

Programação MatLab

Enviado por

Dados do documento

Descrição original:

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

Programação MatLab

Enviado por

Direitos autorais:

Formatos disponíveis

Índice de conteúdos

Capítulo 1.Programação em MatLab.........................................................1

Capítulo 1. Programação em MatLab

5. Tipos de dados básicos

Algumas funções predefinidas para manipulação de números complexos são as seguintes:

8. Variáveis predefinidas (constantes)

inf → infinito (∞)

9.1. Operadores e expressões aritméticas

Os operadores aritméticos são os seguintes:

Uma expressão aritmética pode ser criada utilizando:

9.2. Expressões lógicas

Os operadores lógicos operam segundo a tabela seguinte:

A B AND OR XOR NOT (B)

10. Instrução de atribuição

11.1. Definir uma Matriz

11.2. Aceder aos elementos de uma Matriz

11.3. Funções para criar uma Matriz

11.4. Concatenação de Matrizes

11.5. Operadores aritméticos sobre matrizes

11.6. Operações com Matrizes

size(M) → dimensão da matriz M

12. O operador ":"

12.1. O operador ":" sobre Valores Numéricos

12.2. O operador ":" sobre Matrizes

12.3. O operador ":" para exclusão de Linhas ou Colunas

13. Funções matemáticas básicas

As funções trigonométricas são as seguintes:

As funções exponenciais são as seguintes:

log2(x) → logaritmo de x na base 2, log2(x)

Algumas funções numéricas são as seguintes:

gcd(x,y) → máximo divisor comum entre x e y

Algumas funções estatísticas são as seguintes:

14.1. Definição de uma função

De um modo geral, as funções no MatLab são definidas com a seguinte sintaxe:

14.2. Chamada de uma função

15. Comandos de leitura/entrada e escrita/saída padrão

15.1. Comando de leitura

15.2. Comando de escrita

16. Estruturas condicionais

16.1. Estrutura condicional simples

A estrutura simples é implementada com a estrutura "if-end" e tem a seguinte sintaxe:

16.2. Estrutura condicional composta

A estrutura composta é implementada pela estrutura "if-else-end" e tem a seguinte sintaxe:

16.3. Estrutura condicional composta com elseif

Quando é necessário implementar vários níveis de estruturas if-else, é preferível utilizar a

16.4. Estrutura condicional alternativa

17. Estruturas de repetição

17.1. Estrutura "while"

17.2. Estrutura "for"

17.3. Os comandos continue e break

Os comandos continue e break servem para quebrar a continuidade de estruturas de repetição,

18. O comando error

19. Funções para manipular strings

20. Comandos de leitura e escrita de dados formatadas em ficheiros

20.1. Abertura de um ficheiro

Exemplo 1 (o ficheiro "entrada1.txt" não existe):

20.2. Fecho de um ficheiro

20.3. Leitura de dados de um ficheiro

%n.de : notação na forma [-]8.888e88, sendo n o tamanho do campo (número total de

programa: resultado da execução:

A função textread lê os dados de um ficheiro e guarda-os em várias variévis, é um especificador

programa: resultado da execução: