24/04/2017 ALFABETO MATLAB/OCTAVE (texto de Cláudio Scherer junho de 2002)

next
  up  previous  
Next: About this document ... Up: mat_octave Previous: mat_octave 

ALFABETO MATLAB/OCTAVE 
(texto de Cláudio Scherer junho de 2002)
MATLAB é uma linguagem de programação de alto nível para cálculo numérico. É ``software'' proprietário,
pertencente à empresa MathWorks. OCTAVE é também uma linguagem de programação, que tem a mesma
sintaxe que MATLAB, exceto por mínimas diferenças, como veremos. OCTAVE é ``software'' livre, que
acompanha qualquer distribuição do LINUX.

O texto a seguir foi escrito como uma introdução a esta linguagem de programação, que chamaremos de
MATLAB/OCTAVE, pois, como possuem a mesma sintaxe, uma única explicação será suficiente para o
leitor aprender ambas. Onde existirem diferenças, essas serão explicitadas. A escolha de MATLAB/OCTAVE
como linguagem preferencial de programação usada neste livro deve­se à sua simplicidade para ser
aprendida, rapidez para programar, enorme biblioteca de funções e excelentes recursos gráficos.

O nome MATLAB vem de ``MATrix LABoratory'' (laboratório de matrizes). Trata­se de uma linguagem
computacional para cálculo numérico, cujas variáveis são naturalmente matrizes: um escalar é uma matriz 
, um vetor fila ou coluna de n componentes é uma matriz  n ou n , além das matrizes

propriamente ditas, m n, ou mesmo matrizes tri­dimensionais, l m n. Isto evita muitos ``loops'' na

programação, pois as operações são naturalmente interpretadas como ``operações matriciais''. Além disso
MATLAB/OCTAVE trabalha com números complexos sem que o programador precise declará­los como tal.
Em suma, trata­se de uma linguagem de programação extremamente fácil e eficiente. Ela não se propõe a
competir com FORTRAN ou C em rapidez de execução nos casos de computação de alto desempenho, mas
apresenta enormes vantagens de simplicidade e praticidade, como o leitor verá com a prática. Nesta
introdução procuraremos apresentar as noções mais básicas de MATLAB/OCTAVE, para levar o leitor ao
ponto de escrever programas. Um conhecimento mais sofisticado poderá ser adquirido por consulta aos
manuais de MATLAB ou OCTAVE ou ao ``help on line'' (socorro na linha de comando). Com as letras de A
a Z (alfabeto MATLAB/OCTAVE), abaixo, apresentamos uma espécie de ``receituário mínimo'' para se
trabalhar com MATLAB/OCTAVE. Sugerimos ao leitor que leia o texto com a janela MATLAB aberta ou o
comando ``octave'' ativado, executando todas as instruções e os exemplos mencionados. Aspas, ``...'', são
usadas no texto para destacar os termos técnicos de MATLAB/OCTAVE, mas não devem ser usadas pelo
operador ao empregar estes termos. A tecla enter é indicada, em algumas instruções, por  .

A) Formatos das variáveis na tela: Há vários formatos de apresentação na tela dos resultados das
operações, dos quais destacamos dois: ``short''= 5 algarismos significativos e ``long''= 15 algarismos
significativos (precisão padrão de MATLAB/OCTAVE). O default é ``format short''. Assim, entrando ``pi''
, a resposta é: ans = 3.1416. Após escrever ``format long''  , ``pi''   segue: ans =
3.14159265358979. O nome ``ans'' aparece sempre associado ao resultado da última operação que não
recebeu nome próprio; se, entretanto escrevemos ``x=pi''   segue: x=3.1416; se queremos na tela apenas o
valor de x, sem a o símbolo ``x='', escrevemos ``disp(x)''. Vários outros formatos poderão ser conhecidos
escrevendo­se, na linha de comando, ``help format''. Em OCTAVE ``help comando'' (por exemplo, ``help
format'') produz uma instrução muito resumida. Um pouco mais pode­se obter com ``help ­i comando'', que
apresenta o ponto do manual onde está explicado o comando.

B) Calculadora: MATLAB/OCTAVE é uma ótima máquina de calcular na linha de comando. Por exemplo,
escreva 23*45   ou sqrt(­25)   ou x=4*atan(1)  , e veja os resultados.

C) Workspace: Chama­se assim o conjunto de variáveis definidas (e não apagadas, veja ítem E) em uma
sessão MATLAB/OCTAVE. Por exemplo, defina x=2.3, y=1+2i, z=[1, 0.4, ­2] e entre o comando ``who''.
Veja o resultado. Agora entra ``whos'' e veja o resultado.

https://www.if.ufrgs.br/~leon/metcomp/mat_octave/node1.html 1/9
24/04/2017 ALFABETO MATLAB/OCTAVE (texto de Cláudio Scherer junho de 2002)

D) Variáveis são ``case sensitive'': Isto é, a variável A é diferente da variável a. Letras minúsculas são
usadas em todos os comandos de 
MATLAB/OCTAVE.

E) O comando ``clear'': Apaga todas as variáveis; ``clear a b c'' só apaga as variáveis explicitadas ( a, b, c,
neste caso); ``clear'' é muito útil em programas (veja m­files, no ítem N) para evitar erros em repetições do
programa com dimensões diferentes das matrizes.

F) Variáveis especiais: As variáveis ``pi, eps, i, ans, Inf, NaN'' são definidas por MATLAB/OCTAVE, não
sendo aconselhável usar estes símbolos para as variáveis a serem definidas pelo usuário. Assim ``pi'' é a
constante  , ``eps'' é o menor valor que a precisão do computador consegue distinguir,
geralmente eps  , ``i'' é a unidade imaginária, i= , ``ans'' é o último resultado que não recebeu

nome próprio, ``Inf'', símbolo de ``infinito'', surge como resultado de operações do tipo 1/0, ``NaN'' significa
``Not a Number'', surge de operações do tipo 0/0 ou qualquer operação que contenha ``NaN''.

G) Tipos de variáveis: Escalar= número, real ou complexo; vetor= fila ou coluna de números; matriz m
n; entra­se uma matriz no 
``workspace'' assim: [a , a , ..., a ; a , a , ..., a ; ...; a , ..., a ]; a vírgula entre elementos de
uma fila é opcional, mas o ``ponto e vírgula'' para começar nova fila é necessário. Exemplo: entrando A=[1 2
3 10; 4 5 6 11; 7 8 9 12], segue 

A= 

Há também as variáveis caracter (character strings). Estas são definidas por expressões entre apóstrofes. Por
exemplo, digite t='eis uma variável tipo caracter';   t   e veja o resultado.

H) Dimensões de matrizes: O comando ``size'' dá as duas dimensões da matriz e o comando length dá a
maior dimensão; por ex., sendo A a matriz do ítem anterior, size(A)=3 4 e length(A)=4. As dimensões das
matrizes (e vetores) são muito importantes nas operações matriciais e, por isso, os comandos acima são
muitas vezes usados em programas.

I) Matrizes especiais: Assim como as variáveis escalares especiais (veja ítem F), há também matrizes
especiais definidas em MATLAB/OCTAVE: ``zeros(n)''= matriz n n cujos elementos são todos nulos;

``zeros(m,n)''= matriz m n de elementos nulos; ``ones(n)'' ou ``ones(m,n)''= semelhante a ``zeros'', mas
com elementos iguais a 1; ``rand(n)'' ou ``rand(m,n)''= matriz de elementos aleatórios, uniformemente
distribuídos, no intervalo [0, 1]; ``randn(n)'' ou ``randn(m,n)''= elementos aleatórios, com distribuição
Gaussiana (normal), centrada em 0 e largura 1; ``eye(n)''= matriz identidade n n. Há várias outras matrizes
especiais (menos importantes), que podem ser encontradas nos manuais MATLAB/OCTAVE.

J) Funções elementares: Funções como sin(x), cos(x), sqrt(x), exp(x), log(x), atan(x), abs(x), etc., tem o
significado usual em matemática. Se x é uma matriz, y=cos(x), por exemplo, é a matriz cujos elementos são
y(i,j)=cos(x(i,j)), ou seja, estas funções são aplicadas elemento a elemento.

K) Funções especiais de MATLAB/OCTAVE: Há um grande número de funções definidas em
MATLAB/OCTAVE, das quais destacamos apenas algumas: 
``ceil(x)' e ``floor(x)''=número inteiro que corresponde ao arredondamento do real x, para cima ou para
https://www.if.ufrgs.br/~leon/metcomp/mat_octave/node1.html 2/9
24/04/2017 ALFABETO MATLAB/OCTAVE (texto de Cláudio Scherer junho de 2002)

baixo, respectivamente; 
``fix(x)''= arredondamento para o inteiro mais próximo de zero; 
``round(x)''=arredondamento para o inteiro mais próximo; 
``conj(x)''=complexo conjugado de x; 
``imag(x)''= parte imaginária da variável complexa x; 
``real(x)''= parte real de x; 
``sign(x)''= sinal(+ ou ­) do real x; 
``gcd(x,y)''= máximo divisor comum de x e y; 
``lcm(x,y)''= mínimo múltiplo comum de x e y; 
``rem(x,y)''= resto da divisão x/y; 
Se x e y forem matrizes as funções acima aplicam­se elemento a elemento.

L) Funções matriciais: Há um grande número de funções matriciais, que podem ser encontradas no Manual
ou no ``help''. Apresentamos abaixo as mais importantes, para cada uma das quais o leitor poderá encontrar
mais detalhes e alternativas digitando help ``função'' ou, em OCTAVE, help ­i ``função'': 
``det(A)'': determinante de A; 
``eig(A)'': conjunto de autovalores de A; se escrevemos [V,D]=eig(A), então V será a matriz cujas colunas
são os autovetores de A e D será a matriz diagonal cujos elementos são os autovalores de A; 
``expm(A)'': exponencial matricial de A; lembramos que exp(A) é a exponencial elemento a elemento; 
``logm(A)'': logaritmo matricial, função inversa de expm; 
``inv(A)'': matriz inversa de A; 
A' : conjugada hermitiana de A; 
``sum(A)'': vetor fila cujos elementos são as somas dos elementos das colunas de A; se A é um vetor, sum(A)
é a soma dos elementos de A; 
``trace(A)'': traço, i.e., soma dos elementos da diagonal; 
``norm(V)'': norma do vetor V, i.e., sqrt(sum(abs(V)) 2); 
``sort(V)'':ordena os elementos do vetor V em ordem crescente; para matriz V, ordena cada coluna; para
variáveis do tipo ``caracter''(somente em MATLAB), ordem alfabética; neste caso cada nome deve ser escrito
entre chaves para ser entendido como um elemento e não como um conjunto de letras. 

Exemplo: 
x=[{'Pedro da Silva'};{'Anastácio Antunes'};{'João de Melo Neto'}] 
sort(x)

M) As instruções ``ponto e vírgula (;)'' e ``dois pontos (:)'': ``ponto e vírgula (;)'' é usado ao final de uma
instrução, quando se quer evitar que o resultado da mesma seja escrito na tela; isto é muito importante em
``m­files'' (veja ítem N), quando não se quer mostrar todos os resultados intermediários; Por outro lado, usa­
se o recurso de não colocar o ``ponto e vírgula'' em alguma variável que se quer que seja apresentada na tela
durante a execução para informar que ponto do programa está sendo executado, especialmente em programas
com longos tempos de CPU; No caso de OCTAVE, a impressão na tela, como padrão, só ocorre no final da
execução ou antes de um ``input''; para forçar uma impressão imediata na tela inclui­se o comando
``fflush(stdout)'' logo abaixo da linha que deve ser impressa. ``dois pontos'' se usa para definir uma
seqüência, primeiro elemento : incremento : último elemento. Assim x=1:3:10 significa o vetor x=[1, 4, 7,
10]. O incremento pode ser negativo, como x=10:­2:5; significa x=[10, 8, 6];

N) Script files = m­files = nome.m: Um conjunto de comandos e operações, salvas no arquivo ``nome.m'',
são executadas quando se entra ``nome'' na linha de comando. Um ``programa'' em MATLAB/OCTAVE é
um ``m­file''. Para editar um m­file usa­se um editor, como qualquer um usado para escrever texto LaTeX. A
versão MATLAB para Windows possui um ótimo editor que se aciona com o ``mouse'' na janela MATLAB.
É usual (e muito conveniente) escrever algumas linhas de comentários ( tudo que vem na linha após o sinal
%) no início de cada m­file. Quando se comanda ``help nome'' as linhas de comentário antes da primeira
instrução aparecem na tela. 

Exemplo de m­file: ``modulo.m'' 
% calcula o módulo de um vetor que o operador fornece 
x=input('deh o vetor [x1, x2, ..., xn]  n') % Forma de entrar dados 

https://www.if.ufrgs.br/~leon/metcomp/mat_octave/node1.html 3/9
24/04/2017 ALFABETO MATLAB/OCTAVE (texto de Cláudio Scherer junho de 2002)

% O símbolo  n ordena o cursor a mudar de linha. 

% Note também que o texto entre parênteses vem entre '...'; 
x2=x*x'; % vetor fila vezes vetor coluna = escalar; 
mod_x = sqrt(x2) % Note que não se deve usar como variável a mesma 
% palavra usada no nome do programa (modulo);

Observação: As variáveis dos ``script­files'' são globais, isto é, são reconhecidas, após execução, como
variáveis do ``workspace'' e também reconhecem, em execução, as variáveis previamente definidas no
``workspace''; por exemplo, após executar ``modulo'' escreva x2   ou x  .

O) Controle de arquivos: Alguns comandos usuais de manejo de arquivos, tanto do LINUX como do DOS
são entendidos pelo MATLAB/OCTAVE. Por exemplo, pode­se escrever, na linha de comando, dir ou ls,
delete mas não rm, cd mas não cd . Usa­se ``save A'' para salvar todas as variáveis do ``workspace'' no

arquivo A.mat, em formato binário, ou save A X Y Z para salvar as variáveis X Y e Z no arquivo A.mat (em
binário) ou save A.ext X ­ascii para salvar X em A.ext (a extensão pode ser qualquer) em formato ascii, o
que é útil quando se quer editar o arquivo A.ext. O comando ``load A'' carrega o conteúdo de A.mat no
``workspace''.

P) Construção de seqüências: Mencionamos no ítem M que se pode construir uma seqüência de valores
igualmente espaçados usando a instrução ``dois pontos (:)''; Existem outras maneiras: 
1) x=linspace(x , x , num): num pontos igualmente espaçados; 

2) x= logspace(x , x ,num): seqüência em escala logarítmica.

Q) Operações matriciais e elemento a elemento: Sejam X e Y duas matrizes. Soma: X+Y só pode ser
realizada se X e Y tiverem as mesmas dimensões; o resultado é a matriz soma dos elementos
correspondentes; o mesmo vale para subtração (­). Multiplicação: X*Y só pode ser realizada se as dimensões
internas forem iguais, isto é, se X for m n e Y for n k, resultando numa matriz m k; X/Y significa

X*Y  e X Y significa X *Y. Potenciação: X 2=X*X; esta operação só pode ser realizada com

matrizes quadradas, mas X*X' e X'*X pode ser realizada com qualquer matriz retangular. Se c é um escalar,
X. c significa a matriz em que cada elemento de X é elevado a c. Se X e Y têm as mesmas dimensões
podem realizar­se as operações de multiplicação, divisão e potenciação elemento a elemento; para isto usa­se
um ``ponto'' antes do sinal da operação: Z= X.*Y resulta na matriz de elementos Z(i,j)=X(i,j)*Y(i,j);
Semelhantemente se usa ./ e .  para divisão e potenciação, respectivamente, elemento a elemento. As
funções elementares, como sin, cos, exp, log, abs, etc., quando aplicadas a matrizes, são sempre aplicadas
elemento a elemento.

R) Referenciamento e manipulação de partes de matrizes: 
Muitas vezes se necessita ler ou editar partes de uma matriz; Seja 
A=[1,2,3; 4,5,6; 7,8,9]; Usa­se o ``dois pontos (:)'' para referenciar um conjunto de elementos. Assim A(:,2)
significa o vetor coluna formado pelos elementos de todas as filas e segunda coluna, ou seja, pelos elementos
2, 5 e 8; A(1:2,2:3) contém as duas primeiras filas com as duas últimas colunas, ou seja, é a matriz [2,3; 5,6].

S) Variáveis, relações e operações lógicas: Variáveis lógicas assumem os valores verdadeiro e falso,
representados, respectivamente, pelos inteiros 1 e 0; relações lógicas são testes, cujos resultados são
variáveis lógicas (i.e., 1 ou 0). Seja a=2 e b=3; a relação a b vale 1 e a relação a b vale 0. Seja x=(a b);

x é uma variável lógica de valor 1. Outros operadores relacionais, além de   (menor) e   (maior), são: 

 (igual),   (diferente),   (menor ou igual) e   (maior ou igual).

https://www.if.ufrgs.br/~leon/metcomp/mat_octave/node1.html 4/9
24/04/2017 ALFABETO MATLAB/OCTAVE (texto de Cláudio Scherer junho de 2002)

Operações lógicas são realizadas por: 
``and(A,B)'' ou ``A B'': vale 1 se A e B forem verdadeiros (ou, no caso de A e B serem números, forem
não nulos); 
``or(A,B)'' ou ``A B'': vale 1 se pelo menos um entre A e B for verdadeiro; 

``not(A)'' ou `` A'': vale 1 se A for falso; 
``xor(A,B)'' vale 1 se apenas um entre A e B for verdadeiro.

T) Recorrências (loops): Para repetir N vezes um conjunto de operações se usa: 

for n=1:N; 
conjunto de operações; 
end. 

Obs: A mudança de linha entre operações é opcional, podendo­se escrever varias operações, separadas por ,
ou ; na mesma linha.

Exemplo: 
s=0; for n=1:50; x=rand(1,2); s=s+(x(1) x(2)); end; s

No ``for'' acima a seqüência de valores de n tem incremento 1; para incremento  n, diferente de 1, se usa n 
n: n . Por exemplo, 
``for n=200: ­5: 0''. 

Outra forma de ``loop'' que se repete ``enquanto'' uma condição está satisfeita é: 

while( condição ) 
conjunto de operações; 
end

Exemplo: fatorial de N 
fat=1; N=input('deh inteiro N  n'); 

while(N 1); 
fat=fat*N; N=N­1; 
end; 
disp(fat)

U) Controle e decisão: Quando diferentes operações devem ser ou não realizadas, dependendo de
condições, usa­se ``if'', ``elseif'', ``else'', na seguinte forma: 

if(condição A); 
conjunto A de operações; 
elseif(condição B); 
conjunto B de operações; 
elseif(condição C); 
conjunto C de operações; 
 
 
 
else 
operações alternativas; 
end 

https://www.if.ufrgs.br/~leon/metcomp/mat_octave/node1.html 5/9
24/04/2017 ALFABETO MATLAB/OCTAVE (texto de Cláudio Scherer junho de 2002)

Exemplo: m­file ``seleciona.m'' 
% gera N números aleatórios Gaussianos 
% e conta quantos estão em cada um dos seguintes intervalos: 
% a  , b , c , d  

a=0; b=0; c=0; d=0; 
N=input('deh numero N  n') 

x=randn(1,N); % gera vetor de N num. aleat. Gaussianos 
for j=1:N; 
y=x(j); 
if(y ­1) 
a=a+1; 
elseif(y 0) % note que a condição 

% y  já está satisfeita devido ao if anterior 
b=b+1; 
elseif(y 1) 
c=c+1; 
else 
d=d+1; 
endif 
end 
disp([a b c d])

V) A forma switch­case­otherwise: Quando uma variável (escalar ou caracter) pode assumir um valor
dentre um conjunto não muito grande e, dependendo do valor, diferentes alternativas devem ser seguidas, é
conveniente usar a forma ``switch­case­otherwise'', como segue; seja var a variável em questão; 

switch var 
case valor_a 
operações a 
case{valor_b 
operações b 
 
 
 
otherwise 
operações outras 
end 

Observações: 1)Quando um ``case'' é satisfeito os seguintes não são examinados. 2) Em MATLAB pode­se
por, entre chaves e separados por vírgulas, vários valores associados a um ``case''; as operações indicadas
serão realizadas se var coincidir com um desses valores; 

Exemplo: sw­case.m 
variavel=round(5*rand); 
switch variavel 
case{2,4}, disp('a variável é par') 
case{1,3,5}, disp('a variável é ímpar') 
otherwise, disp('a variável é zero') 
end

W) Função como m­file: O programador pode criar suas próprias funções em m­files que diferem em
alguns aspectos dos de tipo ``programa'', descritos no ítem N. A primeira linha do m­file deve ser 
https://www.if.ufrgs.br/~leon/metcomp/mat_octave/node1.html 6/9
24/04/2017 ALFABETO MATLAB/OCTAVE (texto de Cláudio Scherer junho de 2002)

``function variável=nome_função(argumentos)''. 
A seguir as linhas de comentários que aparecem na tela quando se digita ``help nome_função''. 
Após, o conjunto de instruções para calcular ``variável'' e é opcional, na última linha, ``return''. O m­file deve
levar o nome ``nome_função.m''. 

Exemplo: fgravitacional.m 
function f=fgravitacional(x,y,z,K); 
% calcula as três componentes cartesianas da força gravitacional 
% sobre um corpo quando o atrator está na origem e o corpo 
% na posição r=(x,y,z); O produto GMm é representado por K. 
r=[x,y,z]; 
nr=norm(r); 
nr3=nr 3; 
f=K*r/nr3; 
return

Após digitado e salvo o m­file acima, digite ``help fgravitacional''. 
A seguir digite ``forca=fgravitacional(3, 4, 5, 50)''  . 

Observações:1) Num mesmo m­file podem ser escritas várias funções, sendo que só a primeira pode ser
chamada externamente; as demais são ``sub­funções'' e podem ser chamadas pela função ou por outras sub­
funções do mesmo m­file. 2) As variáveis das funções são ``locais'', isto é, não são reconhecidas no
``workspace'' ou pelas demais funções do m­file, nem uma função reconhece variável que não lhe tenha sido
passada como argumento. 

Há um grande número de funções definidas em MATLAB/OCTAVE, à disposição do usuário, como, por
exemplo, ``fzero'', que encontra zeros de funções ou ``roots'', que encontra as raízes de polinômios, etc. Uma
lista completa delas pode ser encontrada ativando­se Help no menu da janela MATLAB, a seguir Help Desk
e MATLAB Functions by Subject ou by Index.

X) Gráficos em duas e três dimensões; MATLAB/OCTAVE possui excelentes recursos gráficos. Para
complementar as informações apresentadas abaixo, veja ``help plot'', ``help comet'', ``help mesh'' e ``help
hist''. O mais usado dos comandos de gráficos é ``plot'', para curvas em duas dimensões, que pode traçar
qualquer número de curvas, de diferentes formas de linha e cores, com muita facilidade de edição de eixos e
textos. A sintaxe é: 
plot(x1,y1,'s1',x2,y2,'s2',...) 
onde xj são vetores cujas componentes definem os pontos sobre a abscissa, yj o mesmo para a ordenada e sj a
forma e cor da linha (para possíveis formas e cores, ``help plot''). Os sj são opcionais, a forma ``default'' é a
linha cheia. Os vetores xj e yj devem ter a mesma dimensão, que pode ser diferente da dimensão de xk e yk. 

Exemplo: 
x=0:.1:4*pi; y=cos(x).*exp(­x/8); 
plot(x, y, x, sin(x),  , x, 0,  ) 

Observações: 
1) A linha cheia (em azul, se em MATLAB e em vermelho, se em OCTAVE) é a forma e cor ``default'' para a
primeira linha; a sequência ``default'' de cores e as convenções para atribuições de formas para as linhas são
diferentes em MATLAB, que tem software gráfico próprio, e OCTAVE, que usa o Gnu­Plot. Por exemplo, a
instrução   é entendida por MATLAB como ``tracejada, em verde'', mas OCTAVE entende apenas

que é verde. Para aprender sobre os padrões e convenções o leitor deve comandar ``help plot'', em MATLAB,
ou ``help ­i plot'', em OCTAVE. 
2) Pode­se observar detalhes de um gráfico alterando a escala dos eixos, com o comando ``axis'' (veja ``help
axis'')

``plot3(x,y,z)'', só em MATLAB; é o análogo tri­dimensional de ``plot(x,y)''. Resulta numa trajetória que
passa pelos pontos (x(j),y(j),z(j)), para todos os j. 
https://www.if.ufrgs.br/~leon/metcomp/mat_octave/node1.html 7/9
24/04/2017 ALFABETO MATLAB/OCTAVE (texto de Cláudio Scherer junho de 2002)

``comet'' e ``comet3'', só em MATLAB: mesmo que ``plot'' e ``plot3'', porém dinâmico, i.e., mostra a linha
sendo traçada. 

Exemplo: wt=0:.01:8*pi; x=cos(wt); y=sin(wt); comet3(x,y,t)

``mesh(x,y,Z)'', onde x e y são vetores de dimensões n e m, respectivamente e Z é matriz m n, cujos
elementos são funções dos correspondentes elementos de x e y. O resultado é uma superfície sobre o plano x
y. 

Exemplo: 
x=­1: .1: 1; 
y=­2*pi: .1: 2*pi; 
y=y'; 
Z=cos(y)*(x.*x); % note que cos(y) é vetor coluna e (x.*x) é vetor fila; mesh(x,y,Z) 

Uma forma alternativa a ``mesh'' é ``surf''(só em MATLAB), com mesma sintaxe mas que colore todos os
espaços do desenho, enquanto que ``mesh'' traça somente as curvas coloridas.

``hist(x)'': traça um histograma com os elementos do vetor x, contando quantos elementos tem valores dentro
de cada um de dez intervalos consecutivos; ``hist(x,n)'' usa n intervalos; ``X=hist(x,n)'' atribui ao vetor X os
n valores (componentes) que correspondem ao histograma de n intervalos, mas sem traçar o histograma;
assim pode­se traçar uma curva suave em vez de histograma, escrevendo plot(X). Para x matriz hist(x) trata
cada coluna de x com histogramas próprios. Se V é um vetor de n componentes, os intervalos do histograma
hist(x,V) são centrados nas componentes de V. 

Exemplo: 
x=randn(1,100000); 
hist(x,30)   

Alternativamente escreva: 
V=­4:.2:+4; 
y=hist(x,V); 
plot(V,y) 

Se você estiver usando MATLAB, pode substituir a última linha acima por: ``figure; plot(V,y)''; o comando
``figure'' abre uma nova figura, onde será executado ``plot'', e assim você poderá ver as duas figuras na tela
simultaneamente.

Y) Edição de gráficos: (só em MATLAB) Introduza um gráfico qualquer, usando um dos exemplos do ítem
anterior. No menu da janela gráfica escolha ``Tools'' e habilite ``Enable Plot Editing''. Você poderá então
adicionar linhas, eixos, setas e textos, alterar as propriedades dos elementos existentes ou criados, aproximar
e afastar partes do gráfico, girar os gráficos tri­dimensionais, etc. Para escrever símbolos matemáticos pode­
se usar os códigos de LaTeX.

Z) Tempo de CPU: Uma das características importantes do bom programador é usar os recursos que
agilizam a execução do programa. Há várias maneiras de se saber quanto tempo de CPU foi gasto em partes
escolhidas do programa. A mais simples delas consiste em introduzir: 

tic; 
conjunto de comandos; 
toc 

O tempo de CPU gasto pelo conjunto de comandos será registrado na tela. Se você preferir pode dar uma
denominação a este tempo de CPU, escrevendo, por exemplo, em vez de ``toc'', ``tempo1=toc''. Isto pode ser
útil se os tempos de CPU de diferentes partes do programa forem medidos. Para outras opções veja ``help
cputime''.

https://www.if.ufrgs.br/~leon/metcomp/mat_octave/node1.html 8/9
24/04/2017 ALFABETO MATLAB/OCTAVE (texto de Cláudio Scherer junho de 2002)

Uma sugestão para a eficiência de programação e execução: Sempre que possível execute as operações em
forma vetorial ou matricial, em vez de executá­las explicitamente com os elementos dos vetores ou matrizes;
em outras palavras, sempre que possível evite a recorrência ``for''. Por exemplo, se x e y são vetores fila de N
componentes, a operação s=x*y' é ordens de grandeza mais rápida que a forma equivalente, 
s=0;for j=1:N; s=s+x(j)*y(j); end. 
Faça o teste com x=rand(1,100000); y=rand(1,100000); use tic toc.

next
  up  previous  
Next: About this document ... Up: mat_octave Previous: mat_octave
Leonardo Gregory Brunnet 
2002­06­07

https://www.if.ufrgs.br/~leon/metcomp/mat_octave/node1.html 9/9