Académique Documents
Professionnel Documents
Culture Documents
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 devese à 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). Tratase 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
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
escrevendose, na linha de comando, ``help format''. Em OCTAVE ``help comando'' (por exemplo, ``help
format'') produz uma instrução muito resumida. Um pouco mais podese 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: Chamase 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 mfiles, 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; entrase 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 aplicamse 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
``mfiles'' (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 incluise 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 = mfiles = 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 ``mfile''. Para editar um mfile usase 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 mfile. Quando se comanda ``help nome'' as linhas de comentário antes da primeira
instrução aparecem na tela.
Exemplo de mfile: ``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 ``scriptfiles'' 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, podese escrever, na linha de comando, dir ou ls,
delete mas não rm, cd mas não cd . Usase ``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;
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
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 realizarse as operações de multiplicação, divisão e potenciação elemento a elemento; para isto usase
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]; Usase 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);
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, podendose 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=N1;
end;
disp(fat)
U) Controle e decisão: Quando diferentes operações devem ser ou não realizadas, dependendo de
condições, usase ``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: mfile ``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 switchcaseotherwise: 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 ``switchcaseotherwise'', 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 podese
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: swcase.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 mfile: O programador pode criar suas próprias funções em mfiles que diferem em
alguns aspectos dos de tipo ``programa'', descritos no ítem N. A primeira linha do mfile 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 mfile 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 mfile acima, digite ``help fgravitacional''.
A seguir digite ``forca=fgravitacional(3, 4, 5, 50)'' .
Observações:1) Num mesmo mfile podem ser escritas várias funções, sendo que só a primeira pode ser
chamada externamente; as demais são ``subfunções'' e podem ser chamadas pela função ou por outras sub
funções do mesmo mfile. 2) As variáveis das funções são ``locais'', isto é, não são reconhecidas no
``workspace'' ou pelas demais funções do mfile, 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 ativandose 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 GnuPlot. 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) Podese 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 tridimensional 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 podese 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 tridimensionais, 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
20020607
https://www.if.ufrgs.br/~leon/metcomp/mat_octave/node1.html 9/9