*Introduo ao Ambiente Matlab*

*Jos Demisio Simes da Silva*

*Novembro de 1997*

------------------------------------------------------------------------

*Objetivo:*

* Introduzir comandos bsicos do Matlab para permitir um rpido acesso

s facilidades do ambiente. O usurio iniciante poder dispor de uma
referncia rpida para algumas possibilidades de uso do Matlab.

*Observao:*

* O documento como est, no intenciona cobrir todos os tpicos do

Matlab, porque o ambiente, devido sua arquitetura formada por
caixas de ferramentas (toolboxes), possui manuais especficos para
cada caixa de ferramentas, tornando impraticvel a tentativa de
abranger todos os tpicos em um nico documento referncia.

------------------------------------------------------------------------

V o *ndice <#Indice>*
------------------------------------------------------------------------

Este trabalho baseia-se em um documento pblico disponvel na Internet,

nas experincias pessoais do autor, nos manuais do Matlab, no livro
Matlab Verso do Estudante e nas informaes disponveis na pgina da
internet da companhia Mathworks.

------------------------------------------------------------------------

*1. Acessando o Matlab <#no1>*

*2. Utilizando o MATLAB. <#no2>*

*3. Operaes com matrizes e vetores <#no3>*

*4. Declaraes, expresses e variveis; Salvando uma sesso. <#no4>*

*5. Funes de Construo de Matrizes <#no5>*

*6. Loops for, while e blocos if <#no6>*

*7. Funes Escalares. <#no7>*

*8. Funes Vetoriais. <#no8>*

*9. Funes Matriciais. <#no9>*

*10. Edio de Linha de Comando e Chamada <#no10>*

*11. Sub matrizes e notao em dois pontos (:) <#no11>*

*12 Arquivos M <#no12>*

*13. Strings, Mensagens de Erro, Entrada. <#no13>*

*14. Manipulao de Arquivos M <#no14>*

*15. Formato de Sada <#no15>*

*16. Cpia <#no16>*

*17. Grficos <#no17>*

*Bibliografia <#no18>*

------------------------------------------------------------------------
*1. Acessando o Matlab*

* Para acessar o Matlab:

*c:\ > matlab*

* Para sair:

*>> quit*

Em sistemas operacionais pode-se ter o MATLAB em uma janela e o editor

em outra.

ndice <#Indice>

------------------------------------------------------------------------
*2. Utilizando o MATLAB.*

*Entrando com matrizes*

* O MATLAB trabalha essencialmente com um tipo de objeto - matriz

numrica retangular, que pode aceitar inclusive valores complexos.
Todas as variveis no MATLAB representam matrizes. Algumas vezes
matrizes de 1 x 1 so interpretadas como escalares e matrizes com
uma linha ou uma coluna so interpretadas como vetores.

*Introduzindo uma matriz no MATLAB.*

# *Lista explcita de elementos*

*A = [ 1 2 3; 3 4 5; 6 7 8]* que a mesma coisa que entrar como a

seguir:
*A = [ 1 2 3*
* 3 4 5*
* 6 7 8]*

* Os elementos de uma linha podem ser separados por vrgula (,) ou

 espao ( ).
* Nmeros na forma exponencial, deve-se evitar espaos em branco
(exemplo, 3.19e-3).
* Matrizes grandes usar um arquivo M onde possvel editar os erros
facilmente

* Gerao por declaraes embutidas ou funes (ou seja, comandos do

MATLAB )

Exemplos de funes utilizadas para gerar matrizes: *rand, magic, hilb*.

*rand(n)* gera matriz quadrtica de dimenses *n x n*, aleatria com

distribuio uniforme, no intervalo *[0,1]*.
Ex.: *x=rand(3)*

*rand(m,n)* gera uma matriz de dimenses *m x n*.

Ex: *x=rand(3,4)*

*magic(n)* cria uma matriz integral de dimenses *n x n* que matriz

quadrada (linhas e colunas tm a mesma soma).
Ex: *x=magic(4)*

* Em todos os exemplos, m e n so inteiros positivos.

* Outra forma de gerar matrizes atravs de "loops" "for".
* Para especificar um nico elemento da matriz usa-se ndices entre
parnteses.

Ex: *x(2,3)*
Esta notao denota um valor na segunda linha e terceira coluna.

Tente: *x(3,5)*

* Indexadores de matrizes no MATLAB tm que ser inteiros positivos

(no nulos).

ndice <#Indice>
------------------------------------------------------------------------
*3. Operaes com matrizes e vetores*

* Operaes disponveis no Matlab:

* + Adio*
* - Subtrao*
* * Multiplicao*
* ^ Potncia*
* ' Transposio (por exemplo, se
A uma matriz, ento A' sua transposta)*
* \ Diviso esquerda*
* / Diviso direita*

* Tais operaes aplicam-se tambm a escalares (considerados matrizes

 de 1 x 1).
* Se os tamanhos das matrizes so incompatveis, para a operao
matricial, ser gerada uma mensagem de erro, com exceo do caso de
operaes entre escalares e matrizes (para adio, subtrao,
diviso e multiplicao), quando cada entrada da matriz operado
pelo escalar.
* A "diviso de matrizes" necessita de ateno especial. Se A uma
matriz inversvel quadrada e b um vetor coluna (ou linha)
compatvel, ento

*x = A\b* a soluo de *A * x = b* e, respectivamente,

*x = b/A* a soluo de *x * A = b*.

* Na "diviso esquerda", se A quadrada, ento ela fatorada

usando-se eliminao Guassiana e estes fatores so usados para
resolver *A * x = b*. Se A no quadrada, ela fatorada usando
ortogonalizao de Householder com pivoteamente por coluna e os
fatores so usados para resolver o sistema sub ou sobre determinado
no sentido dos mnimos quadrticos. A diviso direita definida
em termos da diviso esquerda por *b/A = (A'\b')*.

* *Operaes com Vetores*.

* As operaes de adio e subtrao operam sobre os elementos da

matriz, ou seja, elemento por elemento. As outras operaes so
operaes matriciais. As operaes *(*,^,\,/ )* podem operar por
elemento da matriz se forem precedidos por ponto

Ex.: *[1,2,3,4] .*[1,2,3,4]* como *[1,2,3,4].^2*

ndice <#Indice>
------------------------------------------------------------------------
*4. Declaraes, expresses e variveis; Salvando uma sesso.*

* Matlab - linguagem de expresses; as expresses que se entra pelo

teclado so interpretadas e avaliadas. Sintaxe das declaraes no
Matlab:

*varivel = expresso*, ou simplesmente

*expresso*

* *Expresses* - compostas por operadores, funes e variveis.

* A avaliao da expresso produz uma matriz, que ento exibida na
tela e atribuda varivel para uso posterior.
* Se a varivel e o sinal de igual ( = ) so omitidos, o Matlab cria
uma varivel ( *ans* de *ans*wer ) e atribui o resultado a ela.
 * Declarao termina com <*carriage return*> (enter). Uma declarao
pode ser continuada na prxima linha com trs ou mais pontos
seguidos por um <*carriage return*>.

* Vrias declaraes podem ser colocadas em uma nica linha se

separadas por vrgulas ou ponto e vrgula.

* Se o ltimo caractere de uma declarao ponto e vrgula, a

impresso suprimida, mas a atribuio feita. (til para suprimir
a impresso de resultados intermedirios).
* Matlab distingue entre letras maisculas e minsculas.

Ex.: *initFF* diferente de *initff*.

* Variveis podem ter at 19 caracteres. No permitido usar

caracteres de pontuao.

* O comando *who* lista as variveis disponveis no espao de trabalho

(workspace).

* Para remover uma varivel do espao de trabalho : *clear nome da

varivel *.
* Para remover mais de uma varivel especifica-se as lista de variveis:

*clear var1 var2 var3*

* O comando *clear* sozinho remove todas as variveis no permanentes.

* A varivel permanente *eps *(epsilon): preciso de cerca de 10-16

(maioria das mquinas) Ela til para determinar tolerncias para a
convergncia em processo iterativos.

* Outras variveis permanentes so:

* pi * razo entre o permetro da

circunferncia e seu dimetro.
* inf*
* NaN *
* i e j*
* realmin*
* realmax*
infinito, por exemplo, 1/0
No-numrico, por exemplo, 0/0
i=j=sqrt(-1) (raiz quadrada de 1)
menor nmero real positivo utilizvel
maior nmero real positivo utilizvel

* Exibio ou execuo pode ser parada em na maioria das mquinas sem

ser necessrio sair do Matlab digitando apenas *CTRL-C*
(*CTRL-BREAK* no PC).

* Salvando uma sesso.

 * Saindo-se do Matlab perde-se todas as variveis. O comando *save*
permite salvar as variveis em disco chamado *matlab.mat*.

Ex.:
*a=rand(3);*
*b=rand(5);*
*c=rand(20);*
*who*
*save*
*clear*

* O comando*load *restaura o espao de trabalho ao seu estado anterior.

Ex.:
*who*
*load*
*who*
* *

* Para salvar apenas algumas variveis presentes no ambiente atual,

especifica-se o comando acompanhado dos argumentos.

*>> save dados a b*

*dados* o nome do arquivo e as variveis so : *a* e *b* .

* Apenas elas estaro no arquivo *dados*, as demais variveis no

ambiente sero perdidas se a sesso for interrompida.

ndice <#Indice>
------------------------------------------------------------------------
*5. Funes de Construo de Matrizes*

* Funes de construo de matrizes so:

*eye* matriz identidade

Ex.: *eye(2)*

*zeros* matriz de zeros

Ex: *zeros(2,2)*

*ones* matriz de *1's*

Ex: *ones(2,2)*

*diag * matriz diagonal

* Se *x* um vetor, *diag(x)* a matriz diagonal com *x *na diagonal;

* x=[1 2 3 1 -1 4];*
*diag(x)*

* Se *A* uma matriz quadrada, ento *diag(A) * um vetor cujos

componentes so os elementos da diagonal de *A*.
*A=[3 11 5; 4 1 -3; 6 2 1]*

*diag(A)*

Tente *diag(diag(A))*

* possvel construir uma matriz a partir de blocos. Exemplo, se *A*

uma matriz *3 x 3*, ento

*B = [A, zeros(3,2); zeros(2,3), eye(2)]*

Matriz *5 x 5*.

*triu* parte triangular superior de uma matriz

*triu(A)*

*tril* parte triangular inferior de uma matriz

*tril(A)*

*rand * matriz gerada aleatoriamente

*rand(5,4)*
*hilb * matriz de *Hilbert*
*hilb(3)*

*magic *quadrado mgico

*magic(3)*

*toeplitz* digite *help toeplitz*

Para ver *toeplitz*, digite *help toeplitz* no *Matlab*.

ndice <#Indice>

------------------------------------------------------------------------
*6. Loops for, while e blocos if*

* Comandos de fluxos do Matlab funcionam como nas linguagens de

programao.
* Sintaxe para um*for* :

*x=[];n=5;*
* for i=1:n, x=[x,i^2], end*

ou
* x=[];n=5;*
* for i=1:n*
* x=[x,i^2]*
* end*

* Observe que as duas declaraes anteriores produziram o mesmo

resultado. Veja que possvel definir uma matriz vazia e que o
ndice varia de *1 *at *n*.

Outro exemplo:
*m=3; n=4;*
*for i=1:m*
* for j=1:n*
* H(i,j)=1/(i+j-1);*
* end*
*end*
*H*

* O resultado uma matriz de *Hilbert* de tamanho *m=3* x *n=4*.

* Colocando-se ponto e vrgula depois de um comando, evita-se a
impresso durante o processamento.
* Para exibir o resultado da matriz *H* utilizou-se o comando *H* sem
ponto vrgula.

* Sintaxe para um loop com while :

*while relaes*
* declaraes*
* end*
Declaraes (grupo de comando) so executadas repetidamente enquanto as
relaes forem satisfeitas.

Ex.: Tomando-se um certo *a*, o seguinte cdigo computa e exibe o menor

inteiro no negativo *n* tal que *2^n >= a*:
*n=0;a=3;*
*while(2^n<a)*
* n=n+1;*
*end*
*n*

* Sintaxe de uma relao *if* :

*if relaes*
* declaraes*
* elseif relaes*
* declaraes*
* else*
* declaraes*
* end*
Declaraes so executadas se a relao for verdadeira.

*if n<0*
* parity=0;*
*elseif rem(n,2)==0*
* parity=2;*
*else*
* parity=1;*
*end*
*parity*
* *

* Operadores relacionais no Matlab so:

* < menor*
* > maior*
* <= menor ou igual*
* >= maior ou igual*
* == igual*
* ~= diferente*

* Observe que *'='* usado para *atribuio a variveis*, enquanto

*'=='* usado em uma relao. As relaes podem ser conectadas ou
quantificadas atravs de operadores lgicos:

* & and*
* | or*
* ~ not*

* Quando aplicada a um escalar, uma relao na realidade *1* ou*0*

dependendo se a relao verdadeira ou falsa.

Ex.:

*3>5*
*ans =*
* 0*
*3<5*
*ans =*
* 1*
*3==5*
*ans =*
* 0*
*3==3*
*ans =*
* 1*

* Quando aplicada a matrizes do mesmo tamanho, a relao uma matriz

de *0's* ou *1's* que d o valor da relao entre entradas
correspondentes. Por exemplo:

*a=rand(5)*

*a =*
* 0.9103 0.3282 0.2470 0.0727 0.7665*
* 0.7622 0.6326 0.9826 0.6316 0.4777*
* 0.2625 0.7564 0.7227 0.8847 0.2378*
* 0.0475 0.9910 0.7534 0.2727 0.2749*
* 0.7361 0.3653 0.6515 0.4364 0.3593*

*b=triu(a)*

*b =*
* 0.9103 0.3282 0.2470 0.0727 0.7665*
* 0 0.6326 0.9826 0.6316 0.4777*
* 0 0 0.7227 0.8847 0.2378*
* 0 0 0 0.2727 0.2749*
* 0 0 0 0 0.3593*

*a==b*

*ans =*
* 1 1 1 1 1*
* 0 1 1 1 1*
* 0 0 1 1 1*
* 0 0 0 1 1*
* 0 0 0 0 1*

* Relao entre matrizes interpretada como verdadeiro por um *while*

ou por um*if* se cada entrada da matriz de relao no nula.
Assim, se voc deseja executar o comando quando as matrizes *A* e
*B* so iguais, poderias digitar:

* if A==B*
* comandos*
* end*

* Para executar o comando quando *A* e *B* no so iguais, voc

poderia digitar:

*if any(any(A~=B))*
* comandos*
* end*
*any* retorna "*1*" se um elemento da matriz for igual a *1*.

ou de forma mais simples,

*if A~=B else*

* comandos*
* end*

* Observe que *if A~=B, comandos, end* no far o que se deseja uma
vez que o comando executaria apenas se cada umas das entradas
correspondentes em *A* e *B* diferem. As funes *any *e *all* podem
ser usadas de forma criativa para reduzir as relaes matriciais
para vetores ou escalares. No cdigo acima, a funo *any *foi
chamada duas vezes, pois ela um operador vetorial (seo 8).

*all* retorna 1 se todos os elementos da matriz forem diferente de zero.

ndice <#Indice>

------------------------------------------------------------------------
*7. Funes Escalares.*

* Algumas funes no Matlab operam essencialmente sobre escalares, mas

operam sobre cada elemento se forem aplicadas a uma matriz. As
funes escalares mais comuns so:

*sin* seno *asin* arcoseno *exp*

exponencial * abs* valor absoluto
*round* arredonda *cos* cosseno *acos* arco
cosseno *log* (log natural)
*sqrt* raz quadrada * floor* arredonda na direo de menos infinito
*tan* tangente *atan* arco tangente* rem*
resto da diviso
*sign* funo sinal *ceil* arredonda na direo de mais infinito

ndice <#Indice>
------------------------------------------------------------------------
*8. Funes Vetoriais.*

* Outras funes do Matlab operam essencialmente sobre vetores

(*linha* e *coluna*), mas em uma matriz *m* x *n*, agem sobre coluna
por coluna para produzir um vetor linha com o resultado de sua
aplicao para a cada coluna. possvel operar sobre linha por
linha transpondo-se a matriz, por exemplo: *mean(a')'*.

*a =[ 0.9103 0.3282 0.2470 0.0727 0.7665*

* 0.7622 0.6326 0.9826 0.6316 0.4777*
* 0.2625 0.7564 0.7227 0.8847 0.2378*
* 0.0475 0.9910 0.7534 0.2727 0.2749*
* 0.7361 0.3653 0.6515 0.4364 0.3593]*

*a =*
* 0.9103 0.3282 0.2470 0.0727 0.7665*
* 0.7622 0.6326 0.9826 0.6316 0.4777*
* 0.2625 0.7564 0.7227 0.8847 0.2378*
* 0.0475 0.9910 0.7534 0.2727 0.2749*
* 0.7361 0.3653 0.6515 0.4364 0.3593*

*mean(a)*

*ans = 0.5437 0.6147 0.6714 0.4596 0.4232*

*mean(a')'*

*ans =*
* 0.4649*
* 0.6973*
* 0.5728*
* 0.4679*
* 0.5097*

* Outros exemplos de funes vetoriais so:

*max(a) sum(a) median(a) any(a) min(a) prod(a) all(a) sort(a) std(a)*

*prod* produto dos elementos
*sort * ordena em ordem crescente
*median* mediana

Tentar:
*max(max(A)) e max(A)*

ndice <#Indice>

------------------------------------------------------------------------
*9. Funes Matriciais.*
 * Grande parte da versatilidade do MATLAB vem de suas funes
matriciais. As mais usadas so:

*eig* autovalores e autovetores *chol * fatorizao

de Cholesky
*svd* decomposio em valor singular *inv* inversa
*lu* fatorizao LU *qr *
fatorizao QR
*hess* forma de Hessenberg *schur *decomposio
de Schur
*expm* matriz exponencial *sqrtm *matriz de
raiz quadrada
*poly* caracterstica polinomial *det * determinante
*size* tamanho *norm* norma
1, norma 2, norma F, norma infinita
*cond* nmero de condio na norma 2 *rank* ranque

* As funes no MATLAB podem ter argumentos simples ou mltiplos. Por

exemplo,

*y = eig(a) *ou *eig(a)* produzem um vetor coluna contendo os

autovalores da matriz "*a*".

* y = eig(a)*
*y =*
* 2.7594*
* 0.9232*
* -0.3618 + 0.1449i*
* -0.3618 - 0.1449i*
* -0.0613*

J *[U,D] = eig (a) *produz uma matriz *U* cujas colunas so os

autovetores de "*a*" e a matriz diagonal *D* com os autovalores de "*a*"
na sua diagonal.

*[U,D] = eig (a)*

*U =*
* Columns 1 through 4*
* -0.3454 -0.7798 0.1164 - 0.1629i 0.1164 +
0.1629i*
* -0.5604 0.0010 0.0766 + 0.2393i 0.0766 -
0.2393i*
* -0.4815 0.4525 -0.5920 - 0.0723i -0.5920 +
0.0723i*
* -0.4198 0.3858 0.6555 - 0.2277i 0.6555 +
0.2277i*
* -0.3983 -0.1960 -0.0666 + 0.2348i -0.0666 -
0.2348i*
* Column 5*
* -0.4895*
* -0.4205*
* 0.3115*
* 0.0416*
* 0.6963*
*D =*
* Columns 1 through 4*
* 2.7594 0 0 0*
* 0 0.9232 0 0*
* 0 0 -0.3618 + 0.1449i 0*
* 0 0 0 -0.3618 -
0.1449i*
* 0 0 0 0*
* Column 5*
* 0*
* 0*
* 0*
* 0*
* -0.0613*

ndice <#Indice>

------------------------------------------------------------------------
*10. Edio de Linha de Comando e Chamada*

* A linha de comando do MATLAB pode ser facilmente editada. O cursor

pode ser posicionado com as setas *letf/right *(esquerda/direita) e
a tecla *Backspace *(retorno) ou *Delete* (Excluir) usada para
apagar o caracter esquerda do cursor. Outras caractersticas de
edio tambm esto disponveis. Em um computador PC tente as teclas
*Home*, *End* e *Delete*; em outros sistemas veja *help cedit* ou
digite *cedit.*

* Uma caracterstica conveniente usar as setas *Up/Down* *para rolar

sobre a pilha com comandos anteriores*. possvel, portanto,
relembrar uma linha de comando anterior, edit-la e execut-la. Para
pequenas rotinas, mais conveniente usar isto do que usar um
arquivo M que implica em sair do Matlab para um editor de texto
(sees 12 e 14). Por exemplos, o comando *flopcounts* (seo 15)
para computar o inverso de matrizes de tamanhos diferentes pode ser
comparado chamando-se, editando-se e executando repetidamente as
seguintes linhas:

*a=rand(8); flops(0), inv(a); flops*

*ans =*
* 1320*

Se voc queria comparar desenhos (*plots*) das funes *y=sin(mx) *e

*y=sin(nx) *no intervalo *[0,2*pi]* para vrios *m* e *n*, possvel
fazer os mesmo com a linha de comando:

*m=2; n=3; x=0:0.01:2*pi; y=sin(m*x); z=sin(n*x); plot(x,y,x,z)*

ndice <#Indice>

------------------------------------------------------------------------
*11. Sub matrizes e notao em dois pontos (:)*

* Os vetores e matrizes so frequentemente usados no Matlab para

 atingir efeitos de manipulao sobre dados complexos. A notao
"*dois pontos*" (que usada para gerar vetores e submatrizes) e de
subscrito em vetores so chaves para uma manipulao eficiente
destes objetos. O uso criativo destas caractersticas permite a
minimizao do uso de*loops *(que deixa o Matlab lento) e torna o
cdigo simples e mais compreensvel.

* A expresso *1:5* (j vista nas declaraes de loops *for*) na

realidade o vetor linha *[1 2 3 4 5]*. Os nmeros no precisam ser
inteiros nem incrementados de *1*. Por exemplo,

*0.2:0.2:1.2*
* 5:-1:1*

Exemplo: Uma tabela de senos.

*x=[0.0:0.1:2.0]';*
*y=sin(x);*
*[x y]*

Note que a funo *sin* opera para cada valor de *x*, assim o seno
(coluna da direita) funo do valor de *x* (coluna da esquerda).

* A notao em dois pontos *(:)* pode ser usada para acessar

submatrizes de uma matriz.

Ex.:
*a=[10 20 30 40; 50 60 70 80; 90 100 110 120; 130 140 150 160]*

*a(1:4,3)* corresponde aos 4 valores da coluna 3 da matriz a .

* Os dois pontos*(:)* denotam uma linha inteira ou uma coluna inteira,

por exemplo:

*a(:,3)*
*a(1:4,:)*

* Vetores arbitrrios integrais podem ser usados com subscrito:

*a(:,[2 4])*
que resulta na submatriz com as colunas *2* e *4* da matriz *a* .

* Este uso de subscritos pode ser usado em ambos os lados de uma

declarao de atribuio:

*b=[1 2 3 4; 5 6 7 8; 9 10 11 12; 13 14 15 16]*

*a(:,[2 4 5])=b(:,1:3)*

As colunas *2, 4 *e*5* da matriz *a *foram substitudas pelas colunas

*1, 2 *e*3* da matriz *b* . Note que com este comando a matriz *a*
apresentada por completo com as modificaes ocorridas.
 * possvel multiplicar as colunas *2 *e*4* da matriz*a* pela
matriz*2 x 2 [1 2; 3 4]*:

*a(:,[2 4])= a(:,[2 4]) * [1 2; 3 4]*

Novamente a matriz apresentada por completo junto com as modificaes.

* Se x um vetor de dimenso *n* , veja o efeito da declarao *x =

x(n:-1:1)*.

*x= [ 1 2 3 4 5 6]*
*x=x(6:-1:1)*

*Observao:*

* Pense nas linhas de comandos em Matlab para executar as funes

apresentadas at agora, comparadas com algoritmos equivalentes em
qualquer linguagem de programao.

ndice <#Indice>
------------------------------------------------------------------------
*12 Arquivos M*

* Matlab pode executar um sequncia de declaraes armazenada em

arquivos chamados "*Arquivos M*" (devido extenso "*.m*"). Muito
do trabalho com Matlab est na criao e refinamento de arquivos M.

* Os arquivos M podem ser scripts (roteiros) ou funes.

*Arquivos Scripts.*

* Um *script* consiste em uma sequncia de comandos do Matlab. Se o

arquivo tem um nome, por exemplo, *sequence.m*, ento o comando
*sequence* far o Matlab executar os comandos declarados no arquivo
*sequence.m*. *_Todas as variveis em um script so globais_* e
mudam os valores das variveis de mesmo nome no ambiente da sesso
de Matlab atual.

* Arquivos *scripts* so frequentemente usados para entrar dados em

uma matriz grande.
* Neles os erros de entrada podem ser facilmente editados e eliminados.

Exemplo: Arquivo M chamado *dados.m *com as linhas abaixo:

*a= [*
*1 2 3 4*
*5 6 7 8*
*]*

Executar o arquivo *dados*.

* Um arquivo M pode referenciar outros arquivos M, incluindo

 referncia a si prprio (recursividade).

*Arquivos funes*

* Arquivos funes fornecem flexibilidade ao Matlab. Pode-se criar

novas funes especficas para o problema. Tais funes tm o mesmo
status de qualquer outra funo do Matlab.

* _Em uma funo as variveis so locais_. (Entretanto, a verso 4 do

Matlab permite se declarar uma varivel global dentro de uma funo.
Veja *help global*)

Exemplo de uma funo simples:

*/function a = randint1(m,n)/*
*/% RANDINT1 gera uma matriz de nmeros aleatrios/*
*/% randint1(m,n) retorna uma matriz m x n com valores entre 0 e 9./*
*/a = floor(10*rand(m,n));/*

*/Uma verso mais generalizada:/*

*/function a = randint2(m,n,a,b)/*
*/% RANDINT2 gera uma matriz de nmeros aleatrios/*
*/% randint2(m,n) retorna uma matriz m x n com valores entre 0 e 9./*
*/% randint(m,n,a,b) retorna entradas entre os inteiros a e b/*
*/if nargin < 3, a=0; b=9; end/*
*/a = floor((b-a+1)*rand(m,n))+a;/*
(Digite no editor do Matlab e experimente).

* As funes devem ser gravadas com os mesmos nomes das funes:

*randint1.m* e *randint2.m*.

*Explicao da funo*:

* Primeira linha - nome da funo, os argumentos de entrada e de

sada; *sem esta linha o arquivo um script e no uma funo.*
* Chamando a partir do ambiente Matlab *z = randint2(3,4)*, os nmeros
3 e 4 so atribudos s variveis *m *e*n *na no arquivo da funo.
A sada atribuda varivel *z.* (Como as variveis em uma funo
so locais, seus nomes so independentes daqueles que esto no
ambiente do Matlab atual.)

* O uso de *nargin* (nmero de argumentos de entrada) permite o ajuste

de um valor padro de um varivel de entrada omitida tais como *a
*e*b* na funo exemplo *randint2.m*.

* Uma funo tambm pode ter argumentos de sada mltiplos. Por exemplo:

*/function [mean, stdev]= stat(x)/*

*/% STAT Mdia e Desvio Padro/*
*/% Para um vetor x, stat(x) retorna a mdia e o desvio padro de x./*
*/% Para uma matriz x, stat(x) retorna dois vetores linha contendo/*
*/% respectivamente, a mdia e o desvio padro de cada coluna./*
*/[m,n]=size(x);/*
*/if m == 1/*
*/ m=n; % caso de um vetor linha/*
*/end/*
*/mean = sum(x)/m;/*
*/stdev= sqrt(sum(x.^2)/m - mean.^2);/*
(Crie um arquivo M e tente este comando para um vetor qualquer.)

* Um comando no Matlab *[xm, xd]=stat(x)*, atribui a mdia e o desvio

padro de *x*, s variveis *xm* e *xd*.

* Atribuies isoladas tambm podem ser feitas com uma funo que tem
argumentos de sada mltiplos. Por exemplo, *xm = stat(x)* (sem
colchetes em torno de *xm*) atribui a mdia de *x* *xm*.

* *%* indica que o resto da linha um comentrio; O Matlab ignora o

resto de linha.

* As primeiras linha de comentrios documentam o arquivo M. Servem

para a ajuda on-line e so apresentadas quando se digita o comando:
*help stat*. Esta documentao deve *sempre* estar presente em um
arquivo de funo.

*Observao*:

* Esta funo ilustra algumas das caractersticas do Matlab que podem

ser usadas para produzir cdigo eficiente. Exemplo, *x.^2* a
matriz de quadrados dos componentes de*x*; *sum* uma funo
vetorial (seo 8); sqrt uma funo escalar (seo 7); e
*sum(x)/m* uma operao entre uma matriz e um escalar.
* A funo abaixo, que d o mximo divisor comum de 2 inteiros atravs
do algoritmo Euclidiano, ilustra o uso de uma mensagem de erro.

*/function a = mdc(a,b)/*
*/% MDC Mximo Divisor Comum/*
*/% mdc(a,b) o mximo divisor comum dos inteiros a e b,/*
*/% com a e b diferentes de zero./*
*/a=round(abs(a)); b=round(abs(b))/*
*/if a==0 & b==0/*
*/ error('O mdc no definido quando ambos os nmero so zero')/*
*/else/*
*/ while( b~=0)/*
*/ r = rem(a,b);/*
*/ a = b; b = r;/*
*/ end/*
*/end/*

* Outras caractersticas avanadas so ilustradas no exemplo de funo

que se segue. Como notado anteriormente, alguns dos argumentos de
entrada de uma funo como *tol *no exemplo, podem ser opcionais
atravs do uso de *nargin* (nmero de argumentos de entrada). A
varivel*nargout *pode ser usada de forma similar.
 * Note que o fato da relao ser um nmero (1 quando verdadeiro; 0
quando falso) usado e que, quando os comandos *while* ou *if* so
avaliados, nonzero significa verdadeiro e 0 significa falso. A
funo do Matlab *feval *permite que se tenha uma *string*
(sequncia de caracteres) como uma varivel de entrada, como nome de
uma outra funo.

*/function [b, steps] = bisect(fun, x, tol)/*

*/% BISECT Calcula a raiz de uma funo de uma varivel pelo mtodo da
bisseo./*
*/% bisect(fun, x) retorna uma raiz da funo. fun uma string
contendo o nome/*
*/% nome de uma funo de valor real, de uma varivel real; funes
ordinrias/*
*/% so definidas em arquivos M./*
*/% x um valor inicial (chute). O valor retornado est perto de um
ponto/*
*/% onde a fun muda de sinal. Por exemplo,/*
*/% bisect('sin', 3) PI. Note as aspas em torno de sin./*
*/%/*
*/% Um terceiro argumento opcional especifica uma tolerncia para a
preciso/*
*/% relativa do resultado. O padro eps (valor padro do Matlab para
preciso/*
*/% em ponto flutuante)./*
*/% Um segundo argumento de sada opcional d um matriz contendo a
observao/*
*/% dos passos de execuo; as linhas so da forma [c f(c)]./*

*/% Inicializao/*
*/if nargin < 3 , tol = eps; end/*
*/trace = (nargout == 2)/*
*/if x ~=0, dx = x/20; else, dx = 1/20; end/*
*/a = x dx; fa = feval(fun,a);/*
*/b = x + dx; fb= feval(fun,b);/*

*/% Ache a mudana de sinal/*

*/while (fa > 0) == (fb > 0)/*
*/ dx = 2.0*dx;/*
*/ a = x dx; fa = feval(fun,a);/*
*/ if (fa > 0) ~= (fb > 0), break; end/*
*/ b=x+dx; fb=feval(fun,b);/*
*/end/*
*/if trace, stpes=[a fa; b fb]; end/*

*/% Loop Principal/*

*/while abs(b a) > 2.0 * tol * max(abs(b),1.0)/*
*/ c = a + 0.5*(b-a); fc = feval(fun,c);/*
*/ if trace, steps = [steps; [c fc]]; end/*
*/ if (fb > 0) == (fc > 0)/*
*/ b =c; fb = fc;/*
*/ else/*
*/ a =c; fa =fc;/*
*/ end/*
*/end/*

* Algumas das funes do Matlab so embutidas enquanto outras so

 distribudas em arquivos M. A lista atual de arquivo M do Matlab
ou do usurio pode ser vista com o comando *type nome_da_funo*.
Por exemplo:

*type eig*
*/eig is a built-in function./*

*type randint1*
*/function a = randint1(m,n)/*
*/% RANDINT gera uma matriz de nmeros aleatrios/*
*/% randint(m,n) retorna uma matriz m x n com valores entre 0 e 9./*
*/a = floor(10*rand(m,n));/*
*/ /*
ndice <#Indice>

------------------------------------------------------------------------
*13. Strings, Mensagens de Erro, Entrada.*

* Strings so fornecidas para o Matlab limitadas por aspas simples.

Exemplo: *s = 'Este e um teste.'*

* Strings podem ser apresentadas com a funo *disp*. Por exemplo:

*disp('Esta mensagem esta sendo apresentada')*

* Mensagens de erro podem ser apresentadas pela funo*error.*

*error('A matriz deve ser simetrica')*

*Observao:*
Dentro de um arquivo M esta mensagem pra a execuo e sai do arquivo M.

* Em um arquivo M o usurio pode ser requisitado a entrar com dados de

forma interativa.

Exemplo:
*iter = input("Entre o numero de interacoes : ')*

*Observao*: O comando input no funciona com o Notebook (ambiente

vinculado ao Microsoft Word).

ndice <#Indice>

------------------------------------------------------------------------
*14. Manipulao de Arquivos M*

* Para-se criar ou editar um arquivo M enquanto mantem-se o Matlab

ativo sem perder as variveis globais no ambiente atualmente.
 * Pode-se usar a caracterstica de *! *para chamar um editor de
textos. O comando *!* permite a execuo de comandos do sistema sem
sair do Matlab.

Ex.:*!dir, !rename*, etc.

* Na edio de textos pode-se usar qualquer editor de texto ascii

disponvel no sistema. No windows, quando da instalao o ambiente
Matlab especifica como padro o *notepad*. Entretanto, possvel
especificar qualquer outro editor escolhendo-se a opo *Options *da
barra de menu do Matlab, depois escolhendo a opo *Editor
Preference* e digitar o caminho e o nome do editor escolhido.

* Para verses mais antigas do Matlab o procedimento pode ser diferente.

* No windows, assim como no Unix e nos sistemas que permitem

multiprocessamento, possvel manter tanto a janela do ambiente
Matlab, quanto o editor de texto ativos.

*Observao*:

* De dentro do Matlab, o comando *dir* lista o contedo do diretrio

atual, enquanto o comando *what* lista apenas os arquivos M do
diretrio. Os comandos do Matlab *delete* e *type* podem ser usados
para apagar um arquivo e imprimir um arquivo na tela,
respectivamente, e chdir pode ser usado para mudar o diretrio de
trabalho. Enquanto estes comandos podem duplicar os comandos do
sistema operacional, eles no precisam de um ! antes.

Os arquivos M devem estar acessveis ao Matlab. Nas instalaes em

mainframe e em rede de workstations, os arquivos M pessoais que so
armazenados em um subdiretrio da rea do usurio nomeado <*matlab*>,
por exemplo, sero acessveis ao Matlab a partir de um diretrio no qual
o usurio est.

ndice <#Indice>

------------------------------------------------------------------------
*15. Formato de Sada*

* Os clculos no Matlab so feito com preciso dupla, mas o formato de

apresentao da sada pode ser controlado pelos comandos abaixo:

format short ponto fixo com 4 casas decimais (o padro) 35.8333

format long ponto fixo com 14 casas decimais
35.83333333333334
format short e notao cientfica com 4 casas decimais 3.5833e+01
format long e notao cientfica com 15 casas decimais
35.83333333333334e+01
format hex
hexadecimal
4041eaaaaaaaaaab
format bank duas casa
decimais 35.83
format rat aproximao
racional 215/6
format + positivo, negativo ou
zero +

* Uma vez acionado, o comando escolhido permanece at ser mudado.

* Os comandos de formatao tambm podem ser acionados a partir do
menu de barra do Matlab. Selecione a opo *Options,* dentro dele
selecione *Numerical Format *e mova o cursor sobre o formato desejado.

* *format compact* suprime a maioria das linhas em branco; permite que

mais informao seja colocada na tela ou na pgina. Ele independe de
outros comandos de formatao.

ndice <#Indice>
------------------------------------------------------------------------
*16. Cpia*

* Para se obter uma cpia em arquivo do que aparece na tela, durante a

execuo de um comando do Matlab, usa-se o comando *diary*.

* diary <nome do arquivo>*

* Aps esse comando tudo que aparecer na tela, ser copiado para o
arquivo (*exceto grficos*) especificado. Se o nome do arquivo
omitido, o comando cria um arquivo padro *diary.* O comando
continua escrevendo no arquivo at se digitar:

*diary off* - que desabilita a opo de cpia. Para continuar com a

cpia, suficiente digitar:
*diary on* - que o Matlab volta a escrever no arquivo.

* Arquivo resultante pode ser editado ou impresso, usando-se qualquer

editor de textos.

ndice <#Indice>
------------------------------------------------------------------------
*17. Grficos*

* O Matlab pode produzir grficos em planos (2D e 3D) e em malhas 3D

para superfcies.

*Grficos em Planos:*

* O comando *plot* cria grficos de *x-y* no plano; se*x* e *y *so

 vetores de mesmo tamanho, o comando *plot(x,y) *abre uma janela
grfica e desenha um grfico *x-y* dos elementos de *x* versos os
elementos de*y*.

Exemplo:

*x=-4:.01:4;*
*y=sin(x);*
*plot(x,y)*

*x* uma partio do domnio com tamanho de grade de *0.01*; *y * um

vetor que d os valores do seno nos ns da partio (relembre que o seno
opera em funo do ponto).

* Quando na tela grfica, pressionando qualquer tecla retorna-se para

a tela de comando enquanto o comando *shg *(mostra grfico) e depois
retorna-se para tela grfica atual (funo mais atual: *figure(gcf)*).

Ex.: Desenhar o grfico de *y=exp(-x.^2) *no intervalo*1.5 *a*1.5.*

*x = -1.5:0.01:1.5;*
*y= exp(-x.^2);*
*plot(x,y)*

Note o comando *.^ *significando operao ponto do vetor *x*.

* Tambm possvel fazer um grfico de curvas paramtricas.

Ex.:
*t=0:0.001:2*pi;*
*x=cos(3*t);*
*y=sin(2*t);*
*plot(x,y)*

* O comando *grid *colocauma grade de linhas sobre o grfico atual.

Experimente refazer o comando anterior e depois digite grid.

* Grficos podem ter ttulos, eixos rotulados e textos dentro do

grfico. Para isso usa-se os seguintes comandos que tem strings como
argumentos.

*title ttulo do grfico*

* xlabel rtulo do eixo x*
* ylabel rtulo do eixo y*
* gtext texto posicionado interativamente*
* text posiciona texto na posio especificada*
* *

Exemplos:
*title ('Funcao y = sin(2*x)') *gera o ttulo do grfico.
*gtext('A Funcao')* permite o posicionamento do texto pelo o mouse ou as
teclas de seta. (Pressionando qualquer tecla posiciona-se o texto no
local escolhido.)
 * Os eixos so autoescalonados. Podem ser modificados utilizando-se o
comando axis. Se *c=[ xmin, xmax, ymin, ymax ]* ento o comando

*axis(c)* ajusta o escalonamento dos eixos para os limites definidos no

vetor c.

Por padro o comando axis congela o escalonamento atual para os grficos

subsequentes; *axis('auto') *- retorna-se ao auto escalonamento.

*axis('square')* - garante que a mesma escala usada para ambos os eixos.

*axis(image)* - apresenta imagem com a mesma relao de aspecto da imagem.
*axis off * - desativa os eixos
*axis on* - ativa os eixos.

Para outras caractersticas do comando axis veja *help axis.*

* H duas formas de se fazer grficos mltiplos em uma nica janela.

Considere:

Ex.:
*x=0:0.01:2*pi;*
*y1=sin(x);*
*y2=sin(2*x);*
*y3=sin(4*x);*
*plot(x,y1,x,y2,x,y3)*
Ex: possvel tambm formar um vetor *Y* contendo os valores funcionais
como colunas:

*x=0:0.01:2*pi;*
*Y=[sin(x)', sin(2*x)', sin(4*x)'];*
*plot(x,Y)*

* Outra forma utilizando o comando *hold*.

*hold *- congela a tela do grfico atual de forma que grficos

subsequentes so superimpostos sobre o atual
*hold* novamente desabilita-se a opo.
*hold on * habilita superposio de grficos
*hold off* desabilita superposio de grficos

* possvel alterar os caracteres de tipo de linha e de ponto usados

como padro. O cdigo abaixo ilustra. Digite e execute-o no Matlab.

*x=0:0.01:2*pi;*
*y1=sin(x);*
*y2=sin(2*x);*
*y3=sin(4*x);*
*plot(x,y1,'--',x,y2,'*',x,y3,'+')*

* Observe que uma linha tracejada e uma linha pontilhada, so usadas

para as duas primeiras curvas. A terceira usa o smbolo + em cada
ponto. Os tipos de linhas e marcas so:
Tipos de linha: slido (-), tracejado (--), pontilhado (:), trao e
ponto (-.)
Tipos de Marcas: ponto (.), sinal de adio (+), asterisco (*),
circulo (o), letra x (x)

* O comando *subplot* pode ser usado para particionar a tela e permite

a apresentao simultnea de vrios grficos no superpostos. Por
exemplo, tente as linhas abaixo no Matlab.

*x=0:0.01:2*pi;*
*y1=sin(x);*
*y2=sin(2*x);*
*y3=sin(3*x);*
*y4=sin(4*x)+cos(x);*
*y5=cos(2*x)+sin(3*x);*
*subplot(2,2,1), plot(y1)*
*subplot(2,2,2), plot(y2)*
*subplot(2,2,3), plot(y3)*
*subplot(2,2,4), plot(y4)*

* Observe que o exemplo permite a apresentao da funes y1, y2, y3 e

y4. Modifique o cdigo para apresentar tambm a funo y5.

*Impresso de Grficos.*

O comando *print* permite que se faa uma impresso de uma figura na

impressora ou para um arquivo, em algum formato. Digite help print para
maiores detalhes do comando *print*.

*Grficos em Malhas 3D*

* possvel desenhar superfcies em malhas 3D com a funo *mesh*.

* O comando *mesh(z) *cria um desenho 3D em perspectiva dos elementos

da matriz *z.* A superfcie da grade definida pelas coordenadas*z*
dos pontos, acima de uma grade retangular no plano *x-y.* Por
exemplo, digite e execute o comando *mesh(eye(10)).*

* Para desenhar o grfico de uma funo*z=f(x,y) *sobre um retngulo,

deve-se primeiro definir os vetores *xx* e *yy* que do as parties
dos lados do retngulo. Com a funo meshgrid (domnio da grade)
possvel criar uma matriz x, cujas linhas igualam-se a *xx *e cujas
colunas tm comprimentos de *yy* e, similarmente, uma matriz *y,*
cujas linhas igualam-se matriz *yy *usando-se o comando:

*[x,y]=meshgrid(xx,yy);*

* Depois, computa-se uma matriz *z*, obtida pela avaliao da funo

*f* sobre as matrizes *x *e *y*, com a qual o comando *mesh *pode
ser utilizada.

Por exemplo, digite e execute o cdigo abaixo, com avaliao da funo

*z=exp(-x.^2-y.^2)* sobre o quadrado definido por *[-2,2] x [-2,2].*
*xx=-2:.1:2;*
*yy=xx;*
*[x,y]=meshgrid(xx,yy);*
*z=exp(-x.^2-y.^2);*
*mesh(z)*

* As primeiras linhas podem ser omitidas, se modificarmos a linha de

meshgrid para:

*[x,y]=meshgrid(-2:.1:2, -2:.1:2);*

* Outras formas de desenhos esto disponveis. Por exemplo, veja o

help da funo *plot3.*

Ex.
*x=rand(3,20);*
*plot3(x(1,:),x(2,:),x(3,:))*

ndice <#Indice>
------------------------------------------------------------------------
*Bibliografia*

Sigmon, K. Matlab Primer. University of Florida. 1992

Hanselman, D.; Littlefield, B. Matlab Verso do Estudante: Guia do

Usurio. Makron Books, So Paulo, 1997.

Leonard, N.E.; Levine, W.S. Using Matlab to Analyze and Design Control
Systems. The Mathworks, Addison Wesley, 1995.

Site na internet.
http://www.mathworks.com <http://www.mathworks.com/>
http://www.mathworks.com/education/