Ncleo de Engenharia Biomdica do IST Setembro/Outubro 2008 Responsvel: Gustavo Lopes

Noes gerais sobre o MATLAB e o seu interface grfico

O MATLAB
Nome vem de matrix laboratory

Programa de computador optimizado para clculos

cientficos e de engenharia

Implementa a linguagem de programao do MATLAB

Vantagens
Fcil de usar, muito prtico para prototipagens Suportado em diversas plataformas (Linux, Windows,

Solaris e Mac OS X)
Elevado nmero de funes predefinidas Excelente para visualizar dados tcnicos Integrao com outras linguagens (especialmente Java)

Desvantagens
Preo Vrios milhares de euros Mas: USD 89 para a verso de estudantes (R2007a) Mas: CIIST disponibiliza licenas validadas em rede

ltima verso: R2008a Vrias toolboxes Ver https://delta.ist.utl.pt/software/matlab.php (tarball em https://nebm.ist.utl.pt/~glopes/MATLAB/)

Mais lento que cdigo escrito em C/C++ Especialmente em cdigo no vectorizado

Desktop do MATLAB

Janela de comandos
Permite executar

comandos interactivamente
Executar mais que um

comando de uma vez:

Usar vrgula ou

quebra de linha (shift+enter) Usar ponto e vrgula

Directrio de trabalho

Mostrado o contedo na janela Current Directory Primeiro local de procura de funes Sobrepe-se ao path Local de escrita/leitura para caminhos no totalmente

qualificados

Workspace
Coleco de todas as

variveis em memria Variveis podem ser eliminadas/copiadas/guard adas/carregadas interactivamente pela janela Workspace who lista nomes de variveis whos lista variveis com mais informao (e.g. dimenses, bytes ocupados)

Documentao
help <funo> mostra a documentao de uma

funo particular
help / mostra informao sobre os operadores doc <funo> mostra a documentao de uma

funo ou tpico na janela de ajuda

lookfor <tpico> procura determinado termo na

descrio de uma funo

Tipos de dados
Todas as variveis so

arrays
Arrays lgicos ou de

doubles podem ser esparsos

O MATLAB tem

tipagem fraca (weakly typed)

Criao, acesso, alterao e operaes lgicas

Arrays (1)
So rectangulares Tamanho mnimo 0 por 0 (array vazio) Pode ter qualquer nmero de dimenses (tensor de qualquer

ordem)

size devolve o tamanho (nmero de graus de liberdade) de cada

dimenso

A matriz o array mais bsico O MATLAB no admite arrays unidimensionais, apenas vectores linha e vectores coluna

Arrays (2)
Forma invlida Forma rectangular

Criao de matrizes
Matriz: array de duas dimenses Criada com parnteses rectos [] Elementos das colunas separados por vrgula ou espao Linhas separadas por ; (ponto e vrgula) Exemplo (matriz 2 por 4): mat = [4 1 8 4; 6 9 1 2] ou mat = [4, 1, 8, 4; 6, 9, 1, 2]
mat = 4 6 1 9 8 1 4 2

Criao de matrizes (2)

Por omisso, os arrays so criados com tipo double Converso pode ser feita usando as funes com o mesmo nome dos tipos Funes especializadas: ones(n) ou ones(m, n) array de 1s zeros(n) ou zeros(m, n) array de 0s eye(n) ou eye(m, n) 1s na diagonal, 0s no resto rand(n) ou rand(m, n) nmeros aleatrios com distribuio uniforme entre 0 e 1 randn(n) ou randn(m, n) nmeros aleatrios com distribuio normal padro

Criao de matrizes (3)

Matrizes podem ser criadas por
>> [[1,2;3,4];[5,6]] ans = 1 3 5 2 4 6

concatenao de outras matrizes A concatenao pode ser vertical, horizontal ou mista Alm da sintaxe direita, pode usar-se vertcat e horzcat cat permite concatenao segundo uma direco arbitrria

>> [[1,2;3,4],[5;6]] ans = 1 3 2 4 5 6

Criao de matrizes (4)

>> >> >> >> mat1 = [1 2; 3 4]; mat2 = [5 6; 7 8]; mat3 = [9 10 11 12]; [mat1 mat2; mat3] >> cat(2, mat1, mat2) ans = 1 3 1 3 9 2 4 10 5 7 11 6 8 12 2 4 5 7 6 8 ans =

>> cat(3, mat1, mat2) ans(:,:,1) = 1 3 2 4

>> cat(1, mat1, mat2) ans = 1 3 5 7 2 4 6 8

ans(:,:,2) = 5 7 6 8

Vectores
Matrizes (arrays bidimensionais) em que o tamanho de

uma das dimenses unitrio

isvector testa se um array um vector

Vectores linha podem ser criados com incio:final (passo 1) e incio:passo:final Vectores coluna podem ser criados transpondo vectores

linha (operador .)
>> 1:4, 0:1/3:1 >> (1:4).' ans = 2 3 4

ans = 1
ans = 0

0.3333

0.6667

1.0000

1 2 3 4

 Exerccios
Cria a matriz mat = [3 3 3 3; 4 3 3 3; 5 5 5 5]

concatenando os blocos:
3 * ones(2,3) [5 5 5]

(3:5).

Repete o exerccio anterior recorrendo somente

funo cat para executar a concatenao Que est errado na seguinte expresso?
cat(1, [3 4 5; 5 4 3], [7 6])

Acesso a elementos
Faz-se na forma varivel(ndices 1, ndices 2, )
ndices comeam em 1, no em 0 como na maioria das

linguagens de programao

Acesso linear varivel(ndice nico) Funciona para arrays de qualquer dimenso Devolve uma matriz linha varivel(:) lineariza qualquer array

Acesso a elementos (2)

>> mat = [1 2 3 ; 4 5 6; 7 8 9]
mat = 1 4 7 2 5 8 3 6 9 >> mat(3) ans = 7

>> mat(1:5)
ans = 1 4 7 2 5

A ordem column major order

Acesso a elementos (3)

Acesso no linear Deve ter tantos conjuntos de ndices quanto nmeros de dimenses Conjuntos de ndices separados por vrgula end representa o valor mximo do ndice da dimenso em que aparece (i.e., o tamanho da mesma) Dois pontos, :, seleccionam a respectiva dimenso em toda a largura (equivalente a 1:end) Se o ltimo conjunto de ndices for escalar, elimina-se ltima dimenso (excepto tratando-se j duma matriz)

Acesso a elementos (4)

>> mat = [5 3 2 6; 4 8 6 5; 1 5 7 3] mat =

>> mat(2, :) ans = 4 8 6 5

5 4 1

3 8 5

2 6 7

6 5 3

>> mat(2:end, [1 3]) ans = 4 1 6 7

>> mat(3, 2) ans = 5 >> mat([1 2], [2 4]) ans = 3 8 6 5

 Exerccios
Dada a matrix mat = [3 3 3 3; 4 3 3 3; 5 5 5 5] Extrai a submatriz de mat sem a primeira linha. Resolve o exerccio:
Seleccionando explicitamente os ndices de interesse Recorrendo a um vector construdo com end para as linhas e recorrendo a : para as colunas Extrai a submatriz de mat sem as colunas do meio.

Obtm, de mat, o vector [3 3 3 3 4 3 3 3] recorrendo apenas

a acesso linear e a transposio Seleccionando submatrizes de mat e recorrendo a concatenao, substitui a linha central por [3 3 5 5]

Atribuio a parte de array

O contedo de uma varivel completamente

substitudo por uma atribuio com o nome da varivel no lado esquerdo (lhs)
Exemplo: mat = [1 2; 3 4]

Podem substituir-se apenas alguns elementos Usa-se indexao do mesmo modo com que se extrairiam os elementos Se o lado direito for:

Um escalar, todos os elementos referidos tomam esse valor Um array com as mesmas dimenses que a expresso do lado esquerdo, ento cada elemento referido no lado esquerdo assume o valor correspondente do lado direito

Atribuio a parte de array (2)

>> mat = zeros(3); >> mat([1 3],[1 3]) = 1;
mat = 1 0 1 0 0 0 1 0 1

>> mat = zeros(3); >> mat(1:5) = 10:14

mat = 10 11 12 13 14 0 0 0 0

>> mat = zeros(3); >> mat(1:2,2:3) = [1 2; 3 4] mat = 0 0 0 1 3 0 2 4 0

>> mat = zeros(3); >> mat(1:5) = 10:16 ??? In an assignment A(I) = B, the number of elements in B and I must be the same.

Atribuio a parte de array (3)

As atribuies a arrays podem referenciar do lado

esquerdo:
ndices superiores ao tamanho da respectiva

dimenso, aumentando o tamanho dessa dimenso

So colocados zeros em todos os elementos que no so alvo da atribuio e que no estavam antes definidos

Mais um ndice do que o nmero de dimenses,

adicionando mais uma dimenso ao array

O lado direito tem de ter mesmos tamanhos que o esquerdo Forma alternativa concatenao de criar arrays de dimenso superior a 2

Atribuio a parte de array (4)

ndices superiores
>> mat = ones(2); >> mat(4:5, 3) = [1; 2] mat = 1 1 0 0 0 1 1 0 0 0 0 0 0 1 2

Mais dimenses
>> mat = 2*ones(2); >> mat(:, :, 2) = 3*ones(2) mat(:,:,1) = 2 2 2 2

mat(:,:,2) = 3 3 3 3

 Exerccios
Seja mat = [8 1 6; 3 5 7; 4 9 2]
Substitui a linha do meio por zeros Usando uma nica atribuio, adiciona uma 4 coluna a mat

com a soma dos valores das linhas (e.g. mat(1, 4) deve valer 8+1+6=15). Nota: usa a funo sum(mat, 2) para fazer esta soma ao longo das colunas (dimenso 2). Desloca os valores de mat uma coluna para a direita e uma linha para baixo tal que a matriz passe a ser 4 por 4. A primeira linha e a primeira coluna devem ficar apenas com zeros. Usa trs atribuies a mat. Tenta executar mat(2, :) = []. Que resultado observas?

Arrays lgicos (1)

O valor de verdade representado por 1; falso

representado por 0
>> true >> 5 > 6 ans = 0 >> 6 ~= 7 ans = 1

ans =
1 >> false ans = 0

Arrays lgicos (2)

Operadores > , <, ==, ~=, >=, <=, &, | e xor operam

elemento a elemento
De um dos lados tem de estar

Ou um escalar, caso em que a operao aplicada entre esse escalar e cada um dos elementos do array do outro lado Ou um array com a mesma forma que aquele do outro lado, caso em que a operao aplicada entre elementos homlogos

Para verificar igualdade entre dois arrays, usar isequal

Arrays lgicos (3)

>> mat = [1 3 5; 3 4 5]; >> mat > 3 ans = 0 0 0 1 1 1 >> mat = [1 3 5; 3 4 5]; >> mat > [2 2 6; 4 3 4] ans = 0 0 1 1 0 1

>> class(ans) ans = logical

>> [0 1 0; 0 1 1] | [1 1 0; 0 0 1] ans = 1 0 1 1 0 1

Arrays lgicos (4)

No funciona
>> a = [1 2 3; 4 5 6]; >> b = [1 2; 4 5]; >> a == b ??? Error using ==> eq Matrix dimensions must agree.

Usar isequal
>> a = [1 2 3; 4 5 6]; >> b = [1 2; 4 5]; >> isequal(a,b)

ans =
0

Arrays lgicos (5)

Arrays lgicos podem ser usados como ndices de arrays O array lgico tem de ter a mesma forma que o array que

indexa
Seleccionam os elementos correspondentes s posies

em que o array lgico assume o valor de verdade

devolvido um vector coluna

Arrays lgicos (6)

>> mat = [1 3 5; 3 4 5]; >> mat([0 1 0; 1 1 0]) ??? Subscript indices must either be real positive integers or logicals. >> mat(logical([0 1 0; 1 1 0])) ans = 3 3 4

Ateno que os arrays

so, por omisso, do tipo double

Pode ser necessrio

fazer um converso explcita para o tipo logical

Arrays lgicos (7)

>> mat = [1 3 5; 3 4 5]; >> mat(mat > 3) ans = 4 5 5 >> mat(mat > 3) = 0 mat = 1 3 3 0 0 0

find(logic_mat) devolve

as posies linearizadas onde o argumento verdadeiro

>> mat = [1 3 5; 3 4 5]; >> find (mat == 3) ans = 2 3 >> find(mat > 3 & mat < 5) ans =

Arrays lgicos (8)

[x y] = find(logic_mat)
>> mat = [1 3 5; 3 4 5]; >> [x y] = find(mat >= 3 & mat < 5)
x = 2 1 2

coloca na varivel x as posies das linhas e na varivel y as posies das colunas onde o argumento verdadeiro

y =

1 2 2

 Exerccios
Seja mat uma matriz arbitrria. Como colocarias a 0 todos os seus elementos cujo mdulo fosse inferior a 10^-10? Seja vec = [3 4 7 5 3 9 11 2] Usando isprime, selecciona todos os nmeros primos em vec Usando isprime e find, selecciona a posio do 2 nmero primo em vec Usando isprime, xor e sum, encontra o nmero de elementos de vec que satisfazem, uma, mas no ambas, das seguintes condies:

Elemento primo Elemento maior que 7

Caracteres, clulas, estruturas e referncias para funes

Caracteres (1)
Criados com char(array numrico) ou 'cadeia de
caracteres' (com as plicas)
Primeiro mtodo implica conhecer correspondncia

entre nmeros e caracteres (a codificao usada) O segundo mtodo:

Cria um array 1 por n (uma string), onde n o nmero de caracteres entre as plicas A plica pode ser includa escapando-a com outra plica

A exigncia de que os arrays tm de ser rectangulares

mantm-se!

Caracteres (2)
>> 'uma plica na string:''!' ans = uma plica na string:'! >> size(ans) ans = 1 22 >> ['string 1'; 'string 2 ...'] ??? Error using ==> vertcat CAT arguments dimensions are not consistent. >> ['string 1'; 'string 2'] ans = string 1 string 2

>> ['string 1' 'string 2'] ans = string 1string 2

Clulas (1)
Arrays de MATLAB s podem ter 1 tipo de dados Arrays de clulas permitem guardar vrios tipos de

dados numa s varivel

O array continua a ter s um tipo de dados (clulas) Cada clula pode contm um array arbitrrio
Inclusive, uma clula pode conter um array de clulas

Clulas (2)
Criar uma clula (array de clulas 1 por 1): {array}
>> ca = {[1 3; 2 5]}
ca = [2x2 double] >> ca = [ca {42}] ca = [2x2 double] [42]

>> [{zeros(2)} {1986}; {int8(zeros(3))} {'uma string'}] ans = [2x2 double] [3x3 int8 ] [ 1986] 'uma string'

Clulas (3)
Pode ser usado apenas o operador {} {A B; C D} equivalente a [{A} {B}; {C} {D}] Ex.: {zeros(2) 1986; int8(zeros(3)) 'uma string'} var{indces} = A equivalente var(ndices) = {A} Ex.: ca = {6}; ca{2} = zeros(3); Pode seleccionar-se uma clula particular ou um

subarray de um array de clulas com o operador ()

No entanto, isto no extrai os elementos das clulas!

Clulas (4)
Extraco de elementos de dentro das clulas faz-se

com o operador {}
O operador {} pode ser encadeado O operador () pode aparecer no final Ex.: ca = {4, {zeros(2)}}; ca{2}{1}(2,2)

Extrair mais que um elemento de cada vez resulta em

retorno mltiplo!
Outra soluo que extrasse os elementos de dentro das

clulas seria impossvel, j que, em geral, impossvel combinar os contedos das vrias clulas seleccionadas Concatenao pode ser forada e.g. com cat

Clulas (5)
>> ca = {[1 3; 2 4], 'foo'; zeros(2), 'bar'} ca = [2x2 double] [2x2 double] >> ca(1,:) ans = [2x2 double] >> ca{1,2} ans = foo 'foo' 'foo' 'bar' b = foo >> cat(1, ca{:,1}) ans = 1 2 0 0 3 4 0 0 1 2 3 4 >> [a b] = ca{1,:} a =

 Exerccios
Constri uma string cujo contedo O valor de var

x, onde x o valor do escalar guardado na varivel var

pelos mtodos que se seguem e imprime-a na command window com disp(string):
Usando concatenao horizontal e a funo num2str Usando a funo sprintf (escreve help sprintf)

Por que razo so, em geral, arrays de clulas mais

adequados do que matrizes de caracteres para guardar conjuntos de strings?

 Exerccios
Dado ca = {'matlab', [5 3; 7 6]} Adiciona uma clula com o elemento [8, 7] recorrendo a concatenao Adiciona a linha {'nebm, 5, 6} recorrendo a atribuio Do array de clulas ca obtido: Executa cellplot(ca) Selecciona a primeira coluna de clulas e verifica o resultado de iscellstr aplicado ao resultado Coloca, respectivamente, nas variveis a e b, o contedo das clulas (1,1) e (1,2) num nico comando Porque vlido cat(1, ca{1,2:3}]) mas no [ca{1,2:3}] (equivalente a cat(2, ca{1,2:3}]))?

Estruturas (1)
Tipo com um conjunto de contentores de dados os

campos
Um campo pode conter uma outra estrutura

O campo tem um nome e acedido com variavel.nome Num arrays de estruturas, todos os elementos tm de

conter os mesmos campos

Mas cada estrutura do array de estruturas pode ter um

tipo de dados diferente associado ao mesmo campo

Estruturas (2)
>> salas.nome = 'X02.3'; >> salas.capacidade = 50; >> salas salas = nome: 'X02.3' capacidade: 50 >> salas(2).nome = 'X4.3'; >> salas(2) ans = nome: 'X4.3' capacidade: [] >> salas(2).capacidade = 25; 'X02.3' 'X4.3' >> salas salas = 1x2 struct array with fields: nome capacidade >> salas(2).capacidade ans = 25 >> {salas.nome} (= {salas(:).nome}) ans =

Referncias a funes (1)

Tipo que permite chamar indirectamente uma funo Se var uma referncia a uma funo, a funo pode ser chamada com var(argumento1, argumento2, )

Referncia criada com:

@nome_da_funo @(arg1, arg2, )funo_estilo_lambda

Est a ser descontinuada a criao de arrays no escalares

de referncias para funes

Usar alternativamente arrays de clulas

Referncias a funes (2)

>> fh = @sin; >> fh(pi/6) ans = 0.5000 >> fh = @(x) x.^2; >> fh([0:4]) ans = 0 1 4 9 16 >> fhs = {@sin @tan}; >> fhs{1}(pi/6) ans = 0.5000 >> fhs = @(x) [sin(x) tan(x)]; >> fhs(pi/6) ans = 0.5000 0.5774

>> [@sin @tan] Warning: non-scalar function handles will not be supported past R2008a. ans = @sin @tan

Salvo em atribuies, evitar usar espaos nas definies de funes estilo lambda, ou ento envolver a funo em parnteses, i.e., (@(args) definio)

 Exerccios
Atribui varivel funs um array 1 por 2 do tipo estrutura

com os campos nome e funcao. Os elementos devem ser preenchidos com os pares ('quadrtica', @(x)x^2) e ('cbica', @(x)x^3)
Extrai o valor do campo nome no 2 elemento do array Extrai simultaneamente os campos nome dos 2 elementos e,

numa nica instruo:

Coloca os valores nas variveis a e b Coloca os valores num array de clulas

Cria uma referncia para uma funo (f) que recebe e

devolve uma referncia para uma funo tal que

f: (arg: x -> arg(x)) -> (ret: x -> arg(x).^2) arg(x) um array numrico
Verifica que f(x -> x^2)(2) = 16 ao avaliar a correspondente expresso

MATLAB

M files, estruturas de controlo, funes, funes estilo lambda, passagem por valor, scoping e closures, depurao

M-files
M-files so ficheiros de extenso .m com cdigo

MATLAB
H dois tipos de M-files: Scripts Funes So acedidos pelo nome (removida a extenso) So procurados no directrio de trabalho e no path

Scripts
Operam sobre o workspace base (o mesmo que

usado ao introduzir comandos interactivamente)

No recebem argumentos (argumentos de entrada) No retornam valores (argumentos de sada)

No podem definir funes (excepto funes tipo

lambda)

Scripts (2)

Estruturas de controlo (1)

if executa instrues se dada condio for verdadeira
if expresso1 instrues1; elseif expresso2 instrues2; else instrues3; end

Pode haver mais blocos elseif (ou nenhum). Pode no haver bloco else.

Estruturas de controlo (2)

executa reiteradamente um conjunto de instrues enquanto dada condio for verdadeira Pode usar-se break , continue e return
while
while expresso1 instrues1; end

Exemplo:
>> v = 2; while v < 8000; v = 2*v; end; v
v = 8192

Nota na avaliao de condies (1)

A condio tem de ser uma expresso lgica ou conversvel

para expresso lgica Se a expresso no for escalar, todos os seus elementos tm de ser verdade ou conversveis para verdade para que as instrues sejam executadas Qualquer nmero que no zero convertido para o valor de verdade
>> a = [0 1 1]; >> if a, disp('verdadeiro'), else, disp('falso'), end falso >> a = [5 1 1; 1.4 1 1]; >> if a, disp('verdadeiro'), else, disp('falso'), end verdadeiro

Nota na avaliao de condies (2)

Condies compostas podem no ser completamente

avaliadas
Exemplo: em if 1 || func(), func() nunca avaliada Importante se func() for custosa a avaliar ou tiver efeitos colaterais Pode usar-se o operador | para forar a avaliao de ambos os termos

Funes importantes: any e all Aplicados a vectores, devolvem um escalar Aplicados a uma matriz, actuam ao longo das colunas Pode especificar-se a dimenso em que actuam

Estruturas de controlo (3)

for

itera ao longo de uma varivel

Itera ao longo das colunas Na construo for var=expr, var em cada iterao um vector coluna tirado de uma coluna de expr Pode usar-se break , continue e return Geralmente usado em construes do gnero
for var=inicio:passo:fim

Estruturas de controlo (4)

>> for k=1:3, disp('nova iterao'), disp(k), end nova iterao 1 nova iterao 2 >> var = [(1:3).' (2:4).']; >> for k=var, disp('nova iterao'), disp(k), end nova iterao 1 2 3 nova iterao 2 3 4

nova iterao 3

Nota: evitar usar i e j como iteradores visto estes

representarem a unidade imaginria

Funes de M-files (1)

Um M-file pode definir uma funo pblica (primria) Funo primria tem de ter o mesmo nome que o

ficheiro em que est definida (tirado o .m) Aps terminar o corpo da funo primria, podem ser definidas vrias funes privadas auxiliares (chamadas de subfunes no MATLAB) Dentro do corpo das funes podem ser definidas funes aninhadas (nested functions) Uma funo em MATLAB pode ter retornos mltiplos! (chamados de argumentos de sada no MATLAB)

Funes de M-files (2)

function y = prodpols(coefs, x) %PRODPOLS Avalia polinmio em dado ponto, dados os seus coeficientes. % y = prodpols(coefs, x) avalia o polinmio de coeficientes coefs no ponto % x. Mais precisamente y o somatrio de coefs(i) * x^(i-1) com i desde i % at ao comprimento de coefs, o qual deve ser um vector numrico. if ~isvector(coefs) || ~isnumeric(coefs) error('prodpols:badarg1', ... 'Primeiro argumento tem de ser vector numrico.'); elseif ~isscalar(x) || ~isnumeric(coefs) error('prodpols:badarg2', ... 'Segundo argumento tem de ser escalar numrico.'); end xpow = zeros(size(coefs)); for k=1:length(coefs) xpow(k) = x^(k-1); end y = sum(coefs .* xpow); end

Funes de M-files (3)

>> who >> prodpols([-10 4 4; 1 1 1], 2) ??? Error using ==> prodpols at 8 Primeiro argumento tem de ser vector numrico. >> prodpols([-10 4 4], 2) ans = 14 >> who Your variables are: ans >> help prodpols PRODPOLS Avalia polinmio em dado ponto, dados os seus coeficientes. y = prodpols(coefs, x) avalia o polinmio de coeficientes coefs no ponto x. Mais precisamente y o somatrio de coefs(i) * x^(i-1) com i desde i at ao comprimento de coefs, o qual deve ser um vector numrico.

Funes de M-files (4)

function y = prodpols(coefs, x) %PRODPOLS Avalia polinmio em dado ponto, dados os seus coeficientes. % (documentao e verificao dos argumentos suprimidos) xpow = powers(size(coefs), x); y = sum(coefs .* xpow); end function out = powers(sizecoef, x) %POWERS Subrotina para calcular potncias de x. % out = powers(sizecoef, x) recebe um array com as dimenses dum vector de % coeficientes e calcula as potncias de x tais que out(i) = x^(i-1) com i % desde 1 at ao comprimento indicado por sizecoef. out = zeros(sizecoef); for k=1:max(sizecoef) out(k) = x^(k-1); end end

Funes de M-files (5)

>> help prodpols PRODPOLS Avalia polinmio em dado ponto, dados os seus coeficientes. (documentao e verificao dos argumentos suprimidos) >> help prodpols>powers POWERS Subrotina para calcular potncias de x. out = powers(sizecoef, x) recebe um array com as dimenses dum vector de coeficientes e calcula as potncias de x tais que out(i) = x^(i-1) com i desde 1 at ao comprimento indicado por sizecoef. >> prodpols([-10 4 4], 2) ans = 14

Subfunes podem aparecer em qualquer ordem, desde que

depois da primria, a qual tem de ser sempre a primeira no M-file Subfunes podem chamar outras subfunes

Scope (1)
Scope o contexto em que uma varivel est definida O MATLAB guarda as variveis em workspaces O workspace base usado por scripts e pela linha de

comandos interactiva As funes tm o seu prprio workspace e s podem aceder a outros workspaces
Se alguma varivel for declarada global em ambos os

workspaces Usando as funes evalin ou assignin

Scope (2)
function functeste global gl gl = 3; %varivel global e partilhada com outros workspaces que a %tenham declarado global lo = 3; %varivel local e perder-se- quando a funo retornar end

>> gl = 5; lo = 5; >> functeste >> gl, lo

gl =

>> >> >> >>

global gl gl = 5; lo = 5; functeste gl, lo

Evitar usar este

gl = 5 3 lo = lo = 5 5

mecanismo a favor de argumentos de entrada e sada ou closures

 Exerccios
Constri uma funo partition, que particiona um array de clulas, tal

que:

A funo recebe 3 argumentos cellarr, um array de clulas vectorial 1 por k, com k >= 0 n, um inteiro no negativo (o tamanho das parties) d, um inteiro positivo (o offset entre as parties) A funo devolve 2 argumentos Um array de clulas n por y, tal que cada linha um subarray de cellarr de tamanho n, com os seguintes contedos: Linha 1: [cellarr(1), cellarr(2), , cellarr(n)] Linha 2: [cellarr(1+d), cellarr(2+d), , cellarr(n+d)] Linha 3: [cellarr(1+2d), cellarr(2+2d), , cellarr(n+2d)] etc. Um inteiro positivo com o nmero de parties criadas Nota que y == floor((d+length(cellarr)-n)/d) Todas as linhas tm o mesmo tamanho, logo alguns elementos finais de

cellarr podem no aparecer nas parties Se d > n, alguns elementos do meio no figuraro no resultado

Passagem por valor (1)

Em MATLAB, todas as variveis so passadas por

valor No se podem construir referncias para variveis de modo a obter o mesmo efeito que na passagem por referncia (como em C)
No se podem facilmente construir estruturas de dados

como listas ligadas Excepes: objectos de Java e classes de utilizador que herdam de handle.

Passagem por valor (2)

function teste(a, b) a.campo = 2; b = 4; end >> x.campo = 10; b = 3; >> teste(x, b); >> x, b x = campo: 2 campo: 10 b = b = 4 3 function [a b] = teste(a, b) a.campo = 2; b = 4; end >> x.campo = 10; b = 3; >> [x b] = teste(x, b) x =

Scope (3)
Funes aninhadas tambm tm o seu prprio

workspace
Podem, contudo, aceder aos workspaces das funes

envolventes
Regra: uma varivel guardada no workspace da

funo mais exterior que a usa

Funes envolventes no podem usar variveis que so

argumentos de sada nas funes aninhadas

Scope (4)
function functeste k = 3; a = 1; function nested1 nested2; k = a * 3; function nested2 a = a * 2; end end disp(k); %k == 3 nested1; disp(k); %k == 6 %nested2; Invlido, nested2 s pode ser chamada por nested1 nested1; disp(k); %k == 12 end function functeste function nested for k=1:4 ; end end k = 3; while k <= 5 %ciclo nunca termina! nested; k = k + 1; end end

Scope (5)
O workspace da funo envolvente continua disponvel

funo aninhada mesmo depois de a funo envolvente retornar! Exemplo:

Funo que recebe um conjunto de coeficientes e

devolve a funo polinomial construda com esses coeficientes.

I.e., dado coefs devolve uma funo

Funo devolvida tem um mecanismo para aplicar um

factor de escala persistente, mas altervel, ao polinmio

Scope (6)
Ainda sem o mecanismo para o factor de escala:
function pol = getpol(coefs) %GETPOL Funo polinomial dados os seus coeficientes % pol = getpol(coefs) devolve um handle para uma funo polinomial cujos % coeficientes so dados pelo vector coefs.

function out = powers(x) out = zeros(size(coefs)); for k=1:length(coefs) out(k) = x^(k-1); end end function y = funpol(x) y = sum(coefs .* powers(x)); end
pol = @funpol; end

Scope (7)
Opes para definir o factor de escala persistente Usar variveis globais

Potencialmente perigoso e sem mecanismos de validao (poderia definir-se essa global com uma string, por exemplo)

Adicionar um segundo argumento funo polinomial

devolvida, o factor de escala

Melhor, mas pouco prtico porque se teria de incluir o segundo argumento em todas as chamadas ter-se-ia de guardar o factor de escala nalguma varivel acessvel no mesmo contexto em que se chamar a funo polinomial devolvida

Scope (8)
function [pol setfact] = getpol(coefs) %GETPOL Funo polinomial dados os seus coeficientes % [pol setfact] = getpol(coefs) devolve um handle pol para uma funo % polinomial cujos coeficientes so dados pelo vector coefs e uma funo % de argumento nico que define um factor de escala que ser aplicado a % todas as chamadas funo polinomial devolida
%Funo powers() igual ao exemplo anterior (suprimida por falta de espao) factor = 1; function y = funpol(x) y = factor * sum(coefs .* powers(x)); end function deffactor(fact) if ~isscalar(fact) || ~isnumeric(fact) error('getpol:deffactor:badarg', ... 'O factor tem de ser um escalar numrico.'); end factor = fact; end pol = @funpol; setfact = @deffactor; end

Scope (9)
>> [pol setfact] = getpol([-10 4 4]) pol = @getpol/funpol >> setfact('str') ??? Error using ==> getpol>deffactor at 23 O factor tem de ser um escalar numrico. >> setfact(.5) >> pol(2) ans = 7 >> [pol2 setfact2] = getpol([-10 4 4]); >> setfact2(2); >> pol(2) ans =

setfact = @getpol/deffactor

>> pol(2) ans =

14
7

Depurao (1)

Depurao (2)
>> [pol2 setfact2] = getpol([-10 4 4]); 29 pol = @funpol; K>> dbcont >> pol2(2) 13 out(k) = x^(k-1); K>> whos Name Size Bytes Class Attributes

---- powers ----------------------------------------------------ans 0x0 0 (unassigned) k 1x1 8 double out 1x3 24 double x 1x1 8 double ---- getpol ----------------------------------------------------ans 0x0 0 (unassigned) coefs 1x3 24 double factor 1x1 8 double pol 1x1 32 function_handle setfact 1x1 32 function_handle K>> dbstep 14 K>> dbquit

end

Depurao (3)

dbclear dbcont dbdown dbquit dbstack dbstatus dbstep dbstop dbtype dbup

Remove breakpoint. Continue execution. Change local workspace context. Quit debug mode. Display function call stack. List all breakpoints. Execute one or more lines. Set breakpoint. List M-file with line numbers. Change local workspace context.

Nmero de argumentos (1)

Argumentos de entrada Uma funo pode ser chamada com menos argumentos de entrada do que aqueles que so declarados no cabealho da funo Funo nargin devolve o nmero de argumentos passados No se pode referir argumentos no definidos, pelo que se deve, caso no tenham sido passados todos os argumentos

Emitir um erro (usar nargchk) Atribuir valores por defeito

Nmero de argumentos (2)

function res = teste(a, b) res = a * b; end >> teste(3, 4, 5) ??? Error using ==> teste Too many input arguments. >> teste(3, 4) function res = teste(a, b) if nargin == 0 error(nargchk(1, 2, nargin, 'struct')) elseif nargin == 1 b = 1; end

res = a * b;
end >> teste() ??? Error using ==> teste at 3 Not enough input arguments. >> teste(3) ans = 3

ans =
12 >> teste(3) ??? Input argument "b" is undefined. Error in ==> teste at 2 res = a * b;

Nmero de argumentos (3)

Argumentos de sada Uma chamada a uma funo pode especificar menos argumentos de sada do que aqueles que so declarados no cabealho da funo

No so emitidos erros como nos argumentos de entrada, os retornos extra so simplesmente ignorados Ainda assim, a funo pode verificar nargout para evitar fazer clculos desnecessrios

Podem gerar-se erros com nargoutchk

Nmero de argumentos (4)

function [a b] = teste() a = 3; b = 4; end >> a = teste a = 3 >> [a b] = teste a = 3

b = 4 >> [a b c] = teste ??? Error using ==> teste Too many output arguments.

Nmero de argumentos (5)

Funes podem ter um nmero arbitrrio de

argumentos de entrada e sada

Usar varargin no final da lista de argumentos de

entrada Usar varargout no final da lista de argumentos de sada Variveis varargin e varargout so vectores de clulas
function [a varargout] = prodsum(a, varargin) if length(varargin) >= 1 varargout{1} = sum(varargin{1}); end if length(varargin) == 2 varargout{2} = prod(varargin{2}); end end >> [a b] = prodsum(5) ??? Error using ==> prodsum Too many output arguments. Error in ==> prodsum >> [a b c] = prodsum(5, [2 3 4], [2 3 4]) (a = 5, b = 9, c = 24)

 Exerccios
Altera partition Por forma a que o ltimo argumento seja facultativo. Se este no for fornecido, as parties resultantes devero ser to numerosas quanto possvel, mas sem qualquer sobreposio e de modo a que todos os argumentos sejam validados

Plots 2-D e 3-D, edio

Grficos 2-D
Funo plot plot(y) produz grfico dos elementos do vector y em funo dos respectivos ndices ou, se y for complexo, da parte imaginria em funo da parte real plot(x,y) produz grfico dos elementos do vector y em funo dos elementos do vector x plot(x1,y1,...,xn,yn) produz grficos dos elementos do vector yi em funo dos elementos do vector xi

Os grficos so lineares por troos, entre cada par de

pontos

Exemplos (1)
>> x1=-2*pi:0.1:2*pi; >> x2=-2*pi:1:2*pi; >> plot(x1,sin(x1),x2,sin(x2))

Formatao Bsica
possvel especificar a cor, estilo da linha e

marcadores para os pontos do grfico usando

plot(x1,y1,color_style_marker1,x2,y2,color_style_marker2,...)

tambm possvel adicionar um ttulo ao grfico,

legend-lo e identificar os eixos, usando os comandos title, legend, xlabel e ylabel.

Os limites do sistema de eixos podem ser alterados e

pode ser adicionada uma grelha ao grfico

Exemplos (2)
>> x1=0:pi/100:2*pi; x2=0:pi/10:2*pi; plot(x1,sin(x1),'m--',x2,sin(x2),'ks'); grid on >> figure; plot(x1,sin(x1),'m--',x2,sin(x2),'ks'); xlabel('x (rad)'); ylabel('sin(x)'); title('Grfico da funo sin(x) para x entre 0 e 2\pi'); axis([0 2*pi -1.5 1.5]); grid on

Exemplos (3)
>> x=-pi:pi/100:pi; xm=-pi:pi/10:pi; y1=sin(x); y2=sin(2*x); ym=sin(xm); figure; plot(x,y1,'LineStyle','--','LineWidth',4,'Color','k'); xlabel('x (rad)'); grid on hold on plot(x,y2,'LineStyle',':','LineWidth',2); legend('sin(x)','sin(2x)','Location','SouthEast'); plot(xm,ym,'LineStyle','none','Marker','o','MarkerSize',10,'MarkerEdgeColor','k', 'MarkerFaceColor','r'); hold off text(-pi,0,'\leftarrow sin(-\pi)=0','FontSize',14,'FontWeight','Bold') set(gca,'YTick',[-1 -0.5 0 0.5 1]); set(gca,'XTick',[-pi -pi/2 0 pi/2 pi]);

Exemplos (4)

Exemplos (5)
>> for k=0:pi/50:2*pi plot(sin(k),cos(k),'ro'); axis equal; axis([-1 1 -1 1]) pause(.2); hold on; end

Exemplos (6)
>> for k=0:pi/10:2*pi subplot(1,2,1); line([sin(k) sin(k+pi/10)],[cos(k) cos(k+pi/10)],'Color','g'); axis equal axis([-1.5 1.5 -1.5 1.5]) hold on; subplot(1,2,2); line([sin(k) sin(k+pi/10)],[cos(k) cos(k+pi/10)],'Color','r'); axis([-1.5 1.5 -1.5 1.5]) pause(.5); hold on; end

Exemplos (7)

Exemplos (8)
>> n=randn(1000,1); figure; subplot(3,2,[3 5]); plot(0:.1:2*pi,cos(0:.1:2*pi)); subplot 321; hist(n,10); subplot 322; hist(n,100); subplot 324; grid on; subplot 326;

Janela com vrios grficos

A funo subplot permite a apresentao de vrios

grficos numa mesma janela

subplot(m,n,p) ou subplot mnp divide a janela

numa matriz m por n de subgrficos e selecciona o psimo grfico como grfico activo
Os subgrficos so numerados da esquerda para a direita

ao longo da primeira linha da matriz, depois da segunda e assim por diante

Outros Grficos
Grficos com escalas logartmicas loglog(), semilogy(), semilogx()
>> x=0:.1:5; y=exp(x); figure subplot(1,2,1) plot(x,y,'Color','m','LineWidth',3) grid on subplot(1,2,2) semilogy(x,y, 'Color','m','LineWidth',3) grid on

Outros Grficos (2)

Grficos 3-D plot3(), surf(), mesh(), contour()
>> t2=0:.01:10*pi; [x y]=pol2cart(t2,t2); figure subplot(2,2,1) plot3(x,y,0:3141);grid on subplot(2,2,2) plot(x,y);grid on subplot(2,2,[3 4]) polar(t2,t2,'--r');

sphere, cylinder

Outros Grficos (3)

>> [x y z]=peaks; figure; subplot(1,2,1);mesh(x,y,z); subplot(1,2,2);contour(x,y,z); colormap jet;colorbar

Outros Grficos (4)

area() para colorir a rea por baixo de uma curva e

fill() para criar polgonos coloridos

>> y=[4 2 9 -2 1 3]; area(y)

Outros Grficos (5)

Grficos de Barras e de Queijo bar() e barh(), bar3() e bar3h(), pie() Stem graphs
>> t=0:pi/10:3*pi; y=cos(t); stem(y,'Marker','h', 'MarkerEdgeColor','k', 'MarkerFaceColor','g', 'LineStyle','--', 'Color','g')

 Exerccio
Refazer o Exemplo 5 usando a exponencial complexa a equao da circunferncia em coordenadas cartesianas

Desenhar quadrado preenchido a vermelho

Figure Windows
Quando a funo plot executada o MATLAB abre uma janela

(Figure Window) para apresentar o grfico, caso no haja j uma aberta; no caso de haver janelas abertas o grfico desenhado no sistema de eixos da ltima janela activa, substituindo o que l se encontrava
Pode usar-se o comando hold on para manter o grfico anterior

O comando figure abre uma nova Figure Window numerada a

partir da janela de menor nmero que se encontre aberta

Pode especificar-se o nmero da figura, escrevendo figure(n)

Os comandos close, close figure n e close all fecham ,

respectivamente, a janela actual, a janela especificada no comando e todas as janelas

Figure Windows (2)

A janela permite a

inspeco do grfico desenhado, sendo possvel, por exemplo,

Visualizar os valores dos

pontos Fazer zoom a partes do grfico Mudar a sua orientao (til em 3-D) e mov-lo

Figure Windows (3)

possvel editar o grfico na prpria janela (mudando

cores e estilos das linha, limites dos eixos, etc.) e obter o cdigo correspondente figura com as alteraes efectuadas fazendo File -> Generate M-File
O grfico pode ser guardado em diversos formatos

(.jpg, .png, .fig, .eps)

Construo de interfaces grficos com o GUIDE

Problema
Construir um interface para desenhar polinmios A granularidade do grfico (nmero de pontos da

curva) ser especificada ao abrir o interface Interface ter

Zona onde o grfico desenhado Coleco de lista de coeficientes dos polinmios que se

podem desenhar

Podem adicionar-se listas de coeficientes

Campos onde se escolhe o intervalo onde o grfico

desenhado Boto para desenhar o polinmio correspondente lista de coeficientes seleccionada, no intervalo indicado