Matlab. Guía Rápida de Sentencias y Comandos. Y en España Se Puso El Sol

Agustín
E. González Morales
MATLAB
Guía rápida

Más de 200
sentencias y comandos
con ejemplos
1

Agustín E. González Morales

ÍNDICE

pág.

3 ESQUEMA DE LA DESCRIPCIÓN DE LAS SENTENCIAS Y COMANDOS
4 EMPEZANDO: Intro. Tres puntos. Coma. Punto y coma. clc. quit. ans. pi. inf. NaN. format
6 FUNCIONES TRIGONOMÉTRICAS
7 LOGARITMOS, EXPONENCIALES, RAÍCES, SIGNO, ENTEROS, MCD, MCM, COMPLEJOS
11 VECTORES Y MATRICES
30 POLINOMIOS
33 TIEMPO, FECHA y HORA
34 CADENAS DE CARACTERES
36 HIPERMATRICES
38 ESTRUCTURAS
40 MATRICES DE CELDAS (Cell Arrays)
42 MATRICES DISPERSAS (Sparse Arrays)
44 PROGRAMACIÓN
50 FICHEROS DE COMANDOS y FUNCIONES. VARIABLES
53 FICHEROS DE DATOS: Lectura y escritura
60 SISTEMA OPERATIVO. Comandos
61 DERIVACIÓN, INTEGRACIÓN, RAÍCES DE UNA FUNCIÓN, MÁXIMOS Y MÍNIMOS
63 GRÁFICOS

2

ESQUEMA DE LA DESCRIPCIÓN
DE LAS
SENTENCIAS Y COMANDOS

Se presenta una breve descripción de la sentencia o comando, seguida de un
ejemplo que, si se ejecuta desde la ventana de comandos, aparece precedido por >>:

Ej.

mod(x,y)

Calcula el resto de la división de x entre y.

>> disp(mod(5,4))
1

Si el ejemplo es un programa, se presenta dicho programa y, a
continuación, tras una línea formada por ^, el resultado de su ejecución:

Ej.

A=1;
if A==1
disp('A es uno')
else
disp('A no es uno')
end
B=2;
if B==1
disp('B es uno')
else
disp('B no es uno')
end

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

A es uno
B no es uno
3

EMPEZANDO:
Intro. Tres puntos. Coma. Punto y coma
clc. quit. ans. pi. inf. NaN. format

Intro

Una expresión termina al pulsar Intro.

Tres puntos (…)

Para que una expresión continúe en la línea siguiente, y se interprete como una única expresión,
se introducen tres puntos (…) antes de pulsar Intro.

Coma (,)

Se pueden teclear varias expresiones distintas separadas por comas (,).

>> A=[1,4;9,16];, sqrt(A)
ans =
1 2
3 4

Obsérvese ; seguido de ,. También se puede escribir A=[1,4;9,16]; sqrt(A) sin la coma en medio.

Punto y coma (;)

Tecleando expresiones separadas por punto y coma (;), su resultados se calculan, pero no se
escriben en pantalla.

>> A=[1,4;9,16];disp(sqrt(A))
1 2
3 4

Al poner un (;) al final de sqrt(A), se calcula, pero no se escribe

>> A=[1,4;9,16];sqrt(A);
>>

clc

Limpia la ventana de comandos (Command Window)

4

quit ó exit

Sale de Matlab.

ans

Es la variable por defecto: contiene el resultado de la última línea ejecutada.

>> 3*2
ans =
6
>> a=ans
a =
6

pi

Es el número π.

>> disp(pi)
3.1416

inf

Es un infinito generado al dividir por cero.

>> 1/0
Warning: Divide by zero.
ans =
Inf

NaN

Acrónimo de Not a number (No es un número). Se genera al introducir una indeterminación.

>> 0/0
ans =
NaN

5

format

Establece los formatos numéricos.

disp('123.456789'); a=123.456789;
format rational, disp(a) % Expresa los números como cocientes de enteros
format short, disp(a) % coma fija con 4 decimales (opción por defecto)
format short e, disp(a) % notación científica con 4 decimales
format short g, disp(a) % notación científica o decimal, dependiendo del valor
format long, disp(a) % coma fija con 15 decimales
format long e, disp(a) % notación científica con 15 decimales
format long g, disp(a) % notación científica o decimal, dependiendo del valor
format hex, disp(a) % cifras hexadecimales
format bank, disp(a) % números con 2 cifras decimales
format, disp(a) % Vuelve al formato estándar que es el de 4 decimales

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

123.456789
10000/81
123.4568
1.2346e+002
123.46
1.234567890000000e+002
1.234567890000000e+002
123.456789
405edd3c07ee0b0b
123.46
123.4568

FUNCIONES TRIGONOMÉTRICAS

sin(A)

Calcula el seno de los elementos de la matriz A.
Análogamente: cos (), tan(), asin() y acos().

>>A=[0,pi/2; pi, 3*pi/2];
>>disp(sin(A))
0 1.0000
0.0000 ‐1.0000
6


atan(a)

Calcula el arco tangente y devuelve un ángulo entre –π/2 y π/2.

atan2(a,b)

Calcula el arco tangente y devuelve un ángulo entre –π y π.
Se deben introducen dos valores a y b proporcionales al seno y al coseno.

rad= atan(1); grados=rad*180/pi;
disp(['Ángulo del primer cuadrante: ',num2str(grados)])
% ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
rad=atan2(1,‐1); grados=rad*180/pi;
disp(['Ángulo del segundo cuadrante: ',num2str(grados)])
% ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
rad=atan2(‐1,‐1); grados=rad*180/pi;
disp(['Ángulo del tercer cuadrante: ',num2str(grados)])
% ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
rad= atan(‐1); grados=rad*180/pi;
disp(['Ángulo del cuarto cuadrante: ',num2str(grados)])
%‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Ángulo del primer cuadrante: 45
Ángulo del segundo cuadrante: 135
Ángulo del tercer cuadrante: ‐135
Ángulo del cuarto cuadrante: ‐45

sinh(), cosh(), tanh(), asinh(), acosh(), atanh()

Funciones hiperbólicas. Se emplean de manera similar a las funciones trigonométricas.

LOGARITMOS, EXPONENCIALES, RAÍCES
SIGNO, ENTEROS, MCD, MCM, COMPLEJOS

log(A)

Calcula el logaritmo neperiano o natural de los elementos de A.
7


>> log(2)
ans =
0.6931

log10(A)

Calcula el logaritmo decimal de los elementos de la matriz A.

>> disp(log10(2))
0.3010

exp(A)

Calcula la exponencial de los elementos de la matriz A.

>> disp(exp(1))
2.7183

sqrt(A)

Calcula la raíz cuadrada de los elementos de la matriz A.

>> A=[1,4;9,16];,disp(sqrt(A))
1 2
3 4

sqrtm(A)

Calcula una matriz que multiplicada por sí misma da A.

>> A=[1,4;9,16]; disp( sqrtm(A))
0.4662 + 0.9359i 0.8860 ‐ 0.2189i
1.9935 ‐ 0.4924i 3.7888 + 0.1152i

sign(A)

Devuelve ‐1 si x < 0, 0 si x = 0 y 1 si x > 0. Aplicada a un número complejo, devuelve el vector
unitario en su dirección.

>> A=[‐5,0;5,7];
disp(sign(A))
‐1 0
8

1 1

>> A=3+4i;
disp(sign(A))
0.6000 + 0.8000i

mod(x,y)

Calcula el resto de la división de x entre y.

>> disp(mod(5,4))
1
>> disp(mod(12.34,5.38))
1.5800

round(x)

Redondea x al entero más próximo. (Ver num2str).

>> disp([num2str(round(2.3333)),' ',num2str(round(2.7777)),' ',num2str(round(‐2.7777))])
2 3 ‐3

fix(x)

Redondea x al entero más próximo a cero. Equivale a la parte entera de x. (Ver num2str).

>> disp([num2str(fix(2.3333)),' ',num2str(fix(2.7777)),' ',num2str(fix(‐2.7777))])
2 2 ‐3

floor(x)

Redondea x al entero más próximo a ∞. (Ver num2str).

>> disp([num2str(floor(2.3333)),' ',num2str(floor(2.7777)),' ',num2str(floor(‐2.7777))])
2 2 ‐3

ceil(x)

Redondea x al entero más próximo a ∞. (Ver num2str).

>> disp([num2str(ceil(2.3333)),' ',num2str(ceil(2.7777)),' ',num2str(ceil(‐2.7777))])
3 3 ‐2
9


gcd(A,B)

Calcula el máximo común divisor de A y B.

>> A=24; B=40; disp(gcd(A,B))
8

lcm(A,B)

Calcula el mínimo común múltiplo de A y B.

>> A=24; B=40; disp(lcm(A,B))
120

a+bi ó a+bj

Escribe un número complejo. Se puede emplear i ó j indistintamente, pero Matlab devuelve i. Sin
embargo, si i ó j se han usado previamente como variables, Matlab las considera como tales.

>> disp(3+4i), disp(3+4j)
3.0000 + 4.0000i
3.0000 + 4.0000i

complex(a,b)

Escribe el complejo a+bi.

>> disp (complex(2,1))
2.0000 + 1.0000i

real(x)

Calcula la parte real del complejo x.

>> disp(real(3+4i))
3

imag(x)

Calcula la parte imaginaria del complejo x.

10

>> disp(imag(3+4i))
4

angle(x)

Calcula el argumento en radianes del complejo x.

>> disp(angle(1+1i)) % el argumento es 45º
0.7854

VECTORES Y MATRICES

X=m:p:n

Crea un vector X con valores entre m y n a intervalos de p en p.

>> X=‐1:0.5:1
X =
‐1.0000 ‐0.5000 0 0.5000 1.0000

linspace (a,b,n)

Crea un vector con n valores espaciados entre a y b.

>>disp(linspace (1,2,7))
1.0000 1.1667 1.3333 1.5000 1.6667 1.8333 2.0000

logspace (a,b,n)

Crea un vector con n valores espaciados logarítmicamente.

>> disp(logspace(1,2,5))
10.0000 17.7828 31.6228 56.2341 100.0000

[mx, pmx]=max (X)

Devuelve en mx el valor máximo de los elementos del vector X y su posición pmx dentro de X.

>> X=[1,5,2]; disp(max(X)); [mx, pmx]=max(X)
5
mx =
11

5
pmx =
2

[mn, pmn]=min (X)

Devuelve en mn el valor mínimo de los elementos del vector X y su posición pmn dentro de X.

>>X=[1,5,0]; disp(min(X)); [mn,pmn]=min(X)
0
mn=
0
pmn=
3

sum(X)

Suma los elementos del vector X.

>> X=[1,5,2]; disp(sum(X))
8

cumsum(X)

Devuelve el vector suma acumulativa de los elementos del vector X.

>> X=[1,5,2]; disp(cumsum(X))
1 6 8

mean(X)

Calcula el valor medio de los elementos del vector X.

>> X=[1,5,2]; disp(mean(X))
2.6667

std(X)

Calcula la desviación típica de los elementos del vector X.

>> X=[1,5,2]; disp(std(X))
2.0817

12

prod(X)

Calcula el producto de los elementos del vector X.

>> X=[1,5,2]; disp(prod(X))
10

cumprod(X)

Devuelve el vector producto acumulativo de los elementos del vector X.

>> X=[1,5,2]; disp(cumprod(X))
1 5 10

[Y,n]=sort(X)

Devuelve el vector ordenado Y, con los elementos del vector X, y un vector n con las posiciones
iniciales de los elementos de X.

>> X=[1,5,2,0]; [Y,n]=sort(X)
Y =
0 1 2 5
n =
4 1 3 2

Nota: Todas las sentencias desde max hasta sort son aplicables a matrices pero para cada columna

A=[1,2; 3,4] ó A=[1 2; 3 4] ó
A=[1 2 (intro en vez de ;)
3,4]

Crea la matriz A .
es un espacio en blanco.

>> A=[1,2;3,4]
A =
1 2
3 4

También es una matriz lo siguiente:

>>v=[1,2,3]; w=[4,5,6];
13

>>matriz=[v;w;0, 0, 1];
>>disp (matriz)
1 2 3
4 5 6
0 0 1

A=[1,2] ó A=[1 2]

Crea un vector fila.

>> A=[1 2]
A =
1 2

A=[1;2] ó
A=[1 (intro)
2]

Crea un vector columna.

>> A=[1
2]
A =
1
2

A(i,j)

Extrae el elemento de la fila i y la columna j de la matriz A .

>>A=[1,2,3;4,5,6;0, 0, 1];
>>disp(A (1,3)) % Elemento en la primera fila y tercera columna de la matriz A
3

A(3, 1:2)

Extrae los 2 primeros elementos de la fila 3.

>>A=[1,2,3;4,5,6;0, 0, 1]; disp(A(3,1:2))
0 0

14

A(1:2,3)

Extrae los 2 primeros elementos de la columna 3.

>>A=[1,2,3;4,5,6;0, 0, 1]; disp(A(1:2,3))
3
6

A(3, :)

Extrae todos los elementos de la fila 3.

>>A=[1,2,3;4,5,6;0, 0, 1];
>> disp(A(3,:))
0 0 1

A(:,3)

Extrae todos los elementos de la columna 3.

>>A=[1,2,3;4,5,6;0, 0, 1]; disp(A(:,3))
3
6
1

A(end,:)

Extrae todos los elementos de la última fila.

>>A=[1,2,3;4,5,6;0, 0, 1];
>> disp(A(end,:))
0 0 1

A(:,end)

Extrae todos los elementos de la última columna.

A(2:3, :)

Extrae todos los elementos de las filas 2 y 3.

>>A=[1,2,3;4,5,6;0, 0, 1];
15

>> disp(A(2:3,:))
4 5 6
0 0 1

A(:,2:3)

Extrae todos los elementos de las columnas 2 y 3.

>>A=[1,2,3;4,5,6;0, 0, 1]; disp(A(:,2:3))
2 3
5 6
0 1

A([1, 3], :)
A([1_ 3], :)

Extrae todos los elementos de las filas 1 y 3.

>>A=[1,2,3;4,5,6;0, 0, 1];
>> disp(A([1,3], :))
1 2 3
0 0 1

A (:,[1, 3])
A(:, [1_ 3])

Extrae todos los elementos de las columnas 1 y 3.

>>A=[1,2,3;4,5,6;0, 0, 1];
>> disp(A(:,[1,3]))
1 3
4 6
0 1

B([1,3],:)=A(1:2,:)

Las filas 1 y 3 de la matriz B son sustituidas por las filas 1 y 2 de A.

>>A=[1,2,3;4,5,6;0, 0, 1]; B=[7,8,9;1,1,1;0,0,0];
>> B([1,3],:)=A(1:2,:);
>> disp(B)
1 2 3
16

1 1 1
4 5 6

A+n

Suma el escalar n a todos los elementos de la matriz A.

>> A=[1,2;3,4]
A =
1 2
3 4
>> disp(A+2)
3 4
5 6

Operadores elemento a elemento: .^ .* ./ .\

Son los operadores ^,*, / y \ precedidos por un punto (.)

>> disp([1,2,3,4]^2)
??? Error using ==> mpower
Matrix must be square.

Error porque la matriz (un vector en este caso) debe ser cuadrada, pero:

>>disp([1,2,3,4].^2)
1 4 9 16

>> disp([1,2,3,4]*[5,6,7,8])
??? Error using ==> mtimes
Inner matrix dimensions must agree.

Error, pero:

>> disp([1,2,3,4].*[5,6,7,8])
5 12 21 32

inv(A)

Calcula la matriz inversa de la matriz A.

>> A=[1,2;3,4]
A =
17

1 2
3 4
>> disp(inv(A))
‐2.0000 1.0000
1.5000 ‐0.5000

X=A\B

En AX=B, con X: vector columna de incógnitas de un sistema lineal y B: vector columna de
términos independientes, se puede emplear dividir por la izquierda \ : (Ver linsolve):

>>X=A\B
Equivalente a
>>X=inv(A)*B

X=linsolve(A,B)

En AX=B, con X: vector columna de incógnitas de un sistema lineal y B: vector columna de
términos independientes:

>> A=[1,2;3,4]; B=[1;2]; X=linsolve(A,B)
X =
0
0.5000

La misma solución que empleando inv():

>> X=inv(A)*B
X =
0
0.5000

det(A)

Calcula el determinante de la matriz cuadrada A.

>> A=[1,2;3,4], det(A)
A =
1 2
3 4
ans =
‐2
18


A'

Calcula la matriz traspuesta de A.

>> A=[1,2;3,4], A'
A =
1 2
3 4
ans =
1 3
2 4

Si los elementos de A son complejos, A' es la matriz conjugada y traspuesta

>> A=[1+i,2+i;1‐i,3‐4i], A'
A =
1.0000 + 1.0000i 2.0000 + 1.0000i
1.0000 ‐ 1.0000i 3.0000 ‐ 4.0000i
ans =
1.0000 ‐ 1.0000i 1.0000 + 1.0000i
2.0000 ‐ 1.0000i 3.0000 + 4.0000i

conj(A)

Calcula la matriz conjugada de A con números complejos.

>> A=[1+i,2+i;1‐i,3‐4i]
A =
1.0000 + 1.0000i 2.0000 + 1.0000i
1.0000 ‐ 1.0000i 3.0000 ‐ 4.0000i
>> disp(conj(A))
1.0000 ‐ 1.0000i 2.0000 ‐ 1.0000i
1.0000 + 1.0000i 3.0000 + 4.0000i

A. '

Calcula la matriz traspuesta de A con números complejos.

>> A=[1+i,2+i;1‐i,3‐4i], A.'
A =
1.0000 + 1.0000i 2.0000 + 1.0000i
1.0000 ‐ 1.0000i 3.0000 ‐ 4.0000i
19

ans =
1.0000 + 1.0000i 1.0000 ‐ 1.0000i
2.0000 + 1.0000i 3.0000 ‐ 4.0000i

A^n

Calcula la potencia n‐sima de la matriz A. Si A es una matriz cuadrada y n un número entero:

A=[1,2;3,4];
>> A^2,A^‐1,inv(A),A^‐3 %Obsérvese que A^‐1=inv(A)
ans =
7 10
15 22
ans =
‐2.0000 1.0000
1.5000 ‐0.5000
ans =
‐2.0000 1.0000
1.5000 ‐0.5000
ans =
‐14.7500 6.7500
10.1250 ‐4.6250

[m,n]=size(A)

Devuelve el número de filas m y columnas n de la matriz A. Si A es cuadrada basta indicar el
primer valor.

>> A=[1,2,3;4,5,6]
A =
1 2 3
4 5 6
>> disp(size(A))
2 3

trace(A)

Devuelve la traza o suma de los elementos de la diagonal de la matriz A.

>> A=[1,2;3,4]
A =
1 2
3 4
20

>> disp(trace(A))
5

eye(n)

Crea una matriz unidad de orden n.

>> disp(eye(2))
1 0
0 1

ones(m,n)

Crea una matriz de unos de tamaño m x n.

>> disp(ones(2,3))
1 1 1
1 1 1

zeros(m,n)

Crea una matriz de ceros de tamaño m x n.

>> disp(zeros(2,3))
0 0 0
0 0 0

rand(m,n)

Crea una matriz de números aleatorios de tamaño m x n.

>> disp(rand(2,5))
0.0185 0.4447 0.7919 0.7382 0.4057
0.8214 0.6154 0.9218 0.1763 0.9355

randn(n)

Crea una matriz de números aleatorios de tamaño n x n con distribución normal de valor medio 0
y varianza 1.

>> disp(randn(2))
0.1746 0.7258
21

‐0.1867 ‐0.5883

magic(n)

Crea una matriz de tamaño n x n con los números 1, 2, …, n*n en la que todas las filas y columnas
suman lo mismo.

>> disp(magic(3))
8 1 6
3 5 7
4 9 2

kron (X,Y)

Crea una matriz con todos los productos de los elementos del vector X por los elementos del
vector Y.
>> X=[1,2];Y=[3,4];disp(kron(X,Y))
3 4 6 8

vander(X)

Crea una matriz de Vandermonde a partir del vector X, cuyas columnas son las potencias de los
elementos de X.

>> X=[1,2,3]; disp(vander(X))
1 1 1
4 2 1
9 3 1

n=length(X)

Calcula el número de elementos del vector X.

>> X=[1,2,5,7]; disp(length(X))
4

[X,D]=eig(A)

Coloca los vectores propios de la matriz A en las columnas de la matriz X y los valores propios en
la diagonal de la matriz diagonal D.

A =
‐3 0 ‐4
22

4 1 4
2 0 3
>> [X,D]=eig(A)
X =
0 ‐0.6667 0.6742
1.0000 0.6667 0.3015
0 0.3333 ‐0.6742
D =
1 0 0
0 ‐1 0
0 0 1

A=diag(X)

Crea una matriz diagonal con los elementos del vector X.

>> X=[1,5]; disp(diag(X))
1 0
0 5

X=diag(A)

Crea un vector columna X con los elementos de la diagonal de la matriz A.

>> A=[1,2;3,4]
A =
1 2
3 4
>> X=diag(A)
X =
1
4

triu(A)

Crea una matriz triangular superior con A.

A =
1 2
3 4
5 6
>>disp( triu(A))
1 2
23

0 4
0 0

tril(A)

Crea una matriz triangular inferior con A.

A =
1 2
3 4
5 6
>> disp.(tril(A))
1 0
3 4
5 6

null(A)

Devuelve una base ortonormal del núcleo de la matriz rectangular A. El núcleo son los vectores X
tales que AX = 0.

>> A=[1,1,1;2,3,4;3,4,5];disp(null(A))
‐0.4082
0.8165
‐0.4082
>> disp(norm(null(A))) % El módulo de null(A) es la unidad
1
>> disp(A*null(A))
% El resultado es el vector (0,0,0) salvo los errores de redondeo expresados por 1.0e‐015 *
1.0e‐015 *
0.2220
‐0.1110
0.1110
>> disp(round(A*null(A))) % Los errores de redondeo se evitan con round
0
0
0

P=orth(A)

Las columnas de P son una base ortonormal del espacio de columnas de A. El número de
columnas de P es el rango de A.

24

>> A=[8 ‐3 ‐3;‐3 8 ‐3;‐3 ‐3 8]
A =
8 ‐3 ‐3
‐3 8 ‐3
‐3 ‐3 8

>> P=orth(A)
P =
‐0.8165 0.0000 ‐0.5774
0.4082 ‐0.7071 ‐0.5774
0.4082 0.7071 ‐0.5774

>> disp([1/sqrt(2),1/sqrt(3),1/sqrt(6),2/sqrt(6)])

% Los elementos de P son 1/sqrt(2), 1/sqrt(3), 1/sqrt(6) y 2/sqrt(6)

0.7071 0.5774 0.4082 0.8165
>> disp(inv(P))
‐0.8165 0.4082 0.4082
‐0.0000 ‐0.7071 0.7071
‐0.5774 ‐0.5774 ‐0.5774
>>disp( P') % Obsérvese que P' = inv(P). O sea, P es ortogonal
‐0.8165 0.4082 0.4082
0.0000 ‐0.7071 0.7071
‐0.5774 ‐0.5774 ‐0.5774
>>disp( inv(P)*A*P) % Obsérvese que inv(P)*A*P es una matriz diagonal
11.0000 0.0000 ‐0.0000
0.0000 11.0000 0.0000
‐0.0000 0.0000 2.0000

rank(A)

Calcula el rango de una matriz rectangular A.

>> A=[1,1,0,2;2,2,‐1,2;0,1,2,‐1; 1,2,1,‐1]; disp( rank(A))
3
norm(X)

Calcula la norma o módulo del vector X.

>> X=[3,4]; disp(norm(X))
5

25

fliplr(A)

Invierte el orden de la columnas de la matriz A.

>> A=magic(3)
A =
8 1 6
3 5 7
4 9 2
>> disp(fliplr(A))
6 1 8
7 5 3
2 9 4

A=[]

Crea la matriz vacía A. Su dimensión es cero.

>> A=[]
A =
[]

A>n

Devuelve una matriz de unos y ceros, con unos en las posiciones donde el elemento de A es
mayor que n. Análogamente con < Menor que, >= Mayor o igual que, <= Menor o igual que, ==
Igual que, ~= Distinto que, (con Alt 126: ~).

>> A=magic(3)
A =
8 1 6
3 5 7
4 9 2
>> disp(A>4)
1 0 1
0 1 1
0 1 0

any(X)

Comprueba los elementos del vector X que cumplen una determinada condición. Devuelve un
uno o un cero.

26

>> any([2,‐3,0,1,7]) % comprueba si algún elemento es distinto de cero y devuelve 1 = verdadero
ans =
1
>> disp(any([2,‐3,0,1,7]>7)) % comprueba si algún elemento es mayor que 7 y devuelve 0 = falso
0

any (A)

Se aplica a cada columna de la matriz A. El resultado es un vector de unos y ceros.

>> A=[1,0,0,2;2,0,‐1,2;0,0,2,‐1;1,0,1,‐1]
A =
1 0 0 2
2 0 ‐1 2
0 0 2 ‐1
1 0 1 ‐1
>>disp(any(A))
1 0 1 1

all(X)

Comprueba si todos los elementos del vector X cumplen una condición. Devuelve un uno o un
cero.

>> all([2,‐3,0,1,7]) % comprueba si todos los elementos son mayores que cero y devuelve 0 = falso
ans =
0
>> all([2,‐3,0,1,7]<8) % comprueba si son menores que 8 y devuelve 1 = verdadero
ans =
1

all(A)

Se aplica a cada columna de la matriz A. El resultado es un vector de ceros y unos.

>> A=magic(3)
A =
8 1 6
3 5 7
4 9 2
>> disp(all(A))
1 1 1

27

Si todos los elementos de A son mayores que cero devuelve un uno:

>> all(all(A))
ans =
1

logical(A)

Genera una variable con el mismo número de elementos de A, con ceros y unos según que el
correspondiente elemento de A sea distinto de cero o no.

A =
16 2 3
5 11 0
9 0 6
>> logical(A)
Warning: Values other than 0 or 1 converted to logical 1
ans =
1 1 1
1 1 0
1 0 1

find(X>n)

Busca índices correspondientes a los elementos del vector X que cumplen una condición. El
resultado es un vector con los índices que cumplen la condición.

>> A=[1,0,0,2;2,0,‐1,2;0,0,2,‐1;1,0,1,‐1]
A =
1 0 0 2
2 0 ‐1 2
0 0 2 ‐1
1 0 1 ‐1
>>find(A>1)
ans =
2
11
13
14

exist('X')

Devuelve 1 si existe la variable X.
28


>> X=1;B=3;disp([exist('X'),exist('B'),exist('b')])
>> disp('La variable b minúscula no existe')
1 1 0
La variable b minúscula no existe

isequal(A,B)

Devuelve 1 si A y B son iguales.

>>A=[1,2;5,6]; B=[3,4;5,6]; C=[1,2;5,6]; disp(isequal(A,B))
>>disp(isequal(A,C)), disp('A y B son distintas, pero A = C')
0
1
A y B son distintas, pero A = C

isempty(A)

Devuelve 1 si la matriz A esta vacía.

>> A=[]; disp(isempty(A))
1

isnan(X)

Comprueba valores NaN y devuelve una matriz de ceros y unos.

>> X=[1,2,0/0,3];
>> disp(isnan(X))
0 0 1 0

isinf(X)

Comprueba valores Inf y devuelve una matriz de ceros y unos.

>> X=[1,2,7/0,3];
>>disp( isinf(X))
0 0 1 0

29

isfinite(X)

Comprueba si los valores son finitos y devuelve una matriz de ceros y unos.

>> X=[1,2,7/0,3];
>> disp(isfinite(X))
1 1 0 1

ischar(X)

Devuelve 1 si X es una cadena de caracteres.

>> X='Pepe'; Y=1; disp(ischar(X)), disp(ischar(Y))
1
0

isglobal(X)

Devuelve 1 si X es una variable global.

isspace(X)

Comprueba si un carácter es un espacio en blanco. Si se le pasa un vector o matriz de caracteres
devuelve un vector o matriz de unos y ceros.

X=' '; disp(isspace(X))
Y='Me llamo Pepe'; disp(Y), disp(isspace(Y))

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

1
Me llamo Pepe
0 0 1 0 0 0 0 0 1 0 0 0 0

POLINOMIOS

X=poly(A)

Devuelve un vector X con los coeficientes del polinomio característico de la matriz cuadrada A.

30

>> A=[2,2;‐2,2]; X=poly(A)
X =
1.0000 ‐4.0000 8.0000

roots(X)

Calcula la raíces del polinomio cuyos coeficientes son los elementos del vector X.

>> X=[1,0,‐8,6,‐10]; disp(roots(X)) % Raíces de x^4 – 8x^2 + 6x – 10
‐3.2800
2.6748
0.3026 + 1.0238i
0.3026 ‐ 1.0238i

polyval(X,a)

Calcula el valor del polinomio definido por el vector X, para x = a.

>> X=[1,0,‐8,6,‐10]; disp(polyval(X,1))
‐11

polyval(X,Y)

Calcula el valor del polinomio X para cada elemento del vector Y.

X=[1,0,‐8,6,‐10]; Y=[1,0]; polyval(X,Y)
ans =
‐11 ‐10

Z=conv(X,Y)

Z es un vector que contiene los coeficientes del producto de los polinomios definidos por los
vectores X e Y.

>> X=[1,2]; Y=[1,1]; disp(conv(X,Y))
1 3 2

[C,R]=deconv[P,Q]

Divide el polinomio P por el polinomio Q. En C se devuelve el cociente y en R el resto.

>> X=[1,2]; Y=[1,1];[C,R]=deconv(X,Y)
31

C =
1
R =
0 1

polyder(X)

Calcula la derivada del polinomio X.

>> X=[1,1,1,1]; disp(polyder(X))
3 2 1

polyfit(x,y,n)

Calcula un polinomio de grado n que se ajusta a los datos (x,y) con el mínimo error cuadrático
medio.

n=0;
for x=[‐1:0.2:1]
n=n+1; y(n)=x^3‐100*x^2+x+100*sin(10*x); % Genera diez puntos (x,y)
end
x=‐1:0.2:1; P=polyfit(x,y,2) % Calcula un
polinomio de segundo grado

n=0;
for x=[‐1:0.2:1]
n=n+1; z(n)=‐100*x^2‐0.1537*x;
% Calcula un polinomio de segundo grado
end
x=‐1:0.2:1; plot(x,y,x,z)
% Dibuja los puntos (x,y)
% y el polinomio de segundo grado

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

P =
‐100.0000 ‐0.1537 0.0000

32

TIEMPO, FECHA y HORA

pause(t)

Espera t segundos antes de ejecutar la siguiente orden de un programa.

disp('Pausa de 5 segundos antes de escribir ME LLAMO PEPE...')
pause(5)
disp('Me llamo Pepe')

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Pausa de 5 segundos antes de escribir ME LLAMO PEPE...
Me llamo Pepe

clock

Devuelve un vector fila de 6 elementos (año, mes, día, hora, minutos, segundos) del reloj interno
del ordenador.

X=clock % Es necesario emplear fix para obtener la parte entera de clock
X=fix(clock);
disp('Tras emplear fix el resultado es:'), disp(X)
disp('Y aclarando cada dato:')
disp(['año: ',int2str(X(1)),' mes: ',int2str(X(2)),' día: ',int2str(X(3)),' hora: ',
int2str(X(4)),' minuto: ',int2str(X(5)),' segundo: ',int2str(X(6))])

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

X =
1.0e+003 *
2.0110 0.0030 0.0070 0.0140 0.0050 0.0468
Tras emplear fix el resultado es:
2011 3 7 14 5 46
Y aclarando cada dato:
año: 2011 mes:3 día: 7 hora: 14 minuto: 5 segundo: 46

date

Devuelve una cadena de caracteres con la fecha actual.

>> disp(date)
08‐Mar‐2011
33


datestr(now)

Devuelve una cadena de caracteres con el día, mes, año, hora, minutos y segundos.

>> disp(datestr(now))
08‐Mar‐2011 16:32:14

weekday(now)

Devuelve el número del día de la semana. El primer día es el domingo, el segundo el lunes, etc.

>> disp(weekday(now))
3

CADENAS DE CARACTERES

double(A)

Convierte en números ASCII cada carácter de la cadena A.

>> A='cadena'; disp(double(A))
99 97 100 101 110 97

char(X)

Convierte el vector de números X en una cadena de caracteres.

>> A='cadena'; double(A), disp(char(ans))
ans =
99 97 100 101 110 97
cadena

disp(X)

Escribe el texto contenido en X.

>> X=[1,2,3,4]; disp(X)
1 2 3 4
>> Y='mi texto'; disp(Y)
mi texto
34

>> disp('mi texto')
mi texto

Para escribir en la misma línea:

>>nombre='María'; edad=12;
>>disp([nombre,' tiene ',num2str(edad),' años']) % Obsérvense los corchetes y consúltese num2str
María tiene 12 años

strcmp(c1, c2)

Compara las cadenas c1 y c2. Si son iguales devuelve un uno, si no, un cero.

>> X='mi texto'; Y='tu texto';
disp(strcmp(X,Y))
0

strcmpi(c1, c2)

Compara cadenas c1 y c2 ignorando la diferencia entre mayúsculas y minúsculas.

>> X='mi texto'; Y='MI TEXTO'; disp(strcmpi(X,Y))
1

strncmp(c1, c2, n)

Compara los n primeros caracteres de las cadenas c1 y c2.

>> X='mi texto'; Y='mis textos'; disp(strncmp(X,Y,2))
1

c1==c2

Compara dos cadenas c1 y c2 carácter a carácter. Devuelve un vector o matriz de ceros y unos.

>> X='mi texto'; Y='mi texta'; disp(X==Y)
1 1 1 1 1 1 1 0

s=[s, 'y más']

Concatena cadenas de caracteres añadiendo la segunda a continuación de la primera.

35

>> X='Tu respuesta'; Y=' es la correcta';
X=[X,Y,' por eso te felicito']
X =
Tu respuesta es la correcta por eso te felicito

int2str(X)

Convierte un número entero en cadena de caracteres.

>>disp( int2str(‐12))
‐12
>> disp(int2str(‐12.37))
‐12

num2str(X,n)

Convierte un número real en cadena de caracteres con cuatro cifras por defecto. Pueden
especificarse n cifras.

>>num2str(pi), disp(num2str(pi,8))
ans=
3.142
3.1415927

str2double(num)

Convierte la cadena de caracteres num, que representa un número real, en dicho número real.

>> num2str(pi,8), disp(str2double(ans))
ans =
3.1415927
3.1416

HIPERMATRICES: Matrices de más de dos dimensiones

A(:,:,1)

>> A(:,:,1)=[1,2;3,4]
A =
1 2
3 4
36

>> A(:,:,2)=[5,6;7,8]
A(:,:,1) =
1 2
3 4
A(:,:,2) =
5 6
7 8

Otro ejemplo:

>> B=rand(2,3,2)
B(:,:,1) =
0.1389 0.1987 0.2722
0.2028 0.6038 0.1988
B(:,:,2) =
0.0153 0.4451 0.4660
0.7468 0.9318 0.4186

También se puede realizar con randn(2,3,2), zeros(2,3,2) y ones(2,3,2).

cat(n,A,B)

Concatena matrices con n=1, 2 ó 3:

>>A=zeros(2,3); B=ones(2,3);), cat(2,A,B)
>>disp(cat(1,A,B))
0 0 0
0 0 0
1 1 1
1 1 1
>>disp(cat(2,A,B))
0 0 0 1 1 1
0 0 0 1 1 1
>>disp(cat(3,A,B))
(:,:,1) =
0 0 0
0 0 0
(:,:,2) =
1 1 1
1 1 1

37

ESTRUCTURAS

Las estructuras son agrupaciones de datos de varios tipos bajo un mismo nombre. Los datos se
llaman campos o miembros.

struct()

Crear estructuras:

>> alumno.nombre='Miguel'
alumno =
nombre: 'Miguel'
>> alumno.DNI=323245
alumno =
nombre: 'Miguel'
DNI: 323245

Otra manera de crear estructuras:

>> alumno=struct('nombre','Miguel','DNI',323245)
alumno =
nombre: 'Miguel'
DNI: 323245

Crear vectores, matrices e hipermatrices de estructuras:

>> alumno(3)=struct('nombre','Miguel','DNI',323245)
alumno =
1x3 struct array with fields:
nombre
DNI
>> disp(alumno(1))
nombre: []
DNI: []
>> disp(alumno(2))
nombre: []
DNI: []
>> disp(alumno(3))
nombre: 'Miguel'
DNI: 323245

Añadir otro campo: Basta crear el campo en uno de los datos

>> alumno(2).edad=18;
38

>> disp(alumno(2))
nombre: []
DNI: []
edad: 18
>> disp(alumno(3))
nombre: 'Miguel'
DNI: 323245
edad: []

Estructuras anidadas:

>> clase=struct('curso','1º','alumno',struct('nombre','Juan','DNI',323245,'edad',18))
clase =
curso: '1º'
alumno: [1x1 struct]
>> disp(clase.alumno(1))
nombre: 'Juan'
DNI: 323245
edad: 18

fieldnames(ST)

Devuelve un vector con los nombres de los campos de la estructura ST.

>> fieldnames(alumno)
ans =
'nombre'
'DNI'
'edad'

isfield(ST,s)

Devuelve 1 si la cadena s es el nombre de un campo de la estructura ST.

>> disp(isfield(alumno,'edad'))
1

isstruct(ST)

Devuelve 1 si la estructura ST existe.

>> disp(isstruct(alumno))
1
39


rmfield(ST,s)

Elimina el campo s de la estructura ST.

>> disp(rmfield(alumno,'edad'))
nombre
DNI

getfield(ST,s)

Devuelve el valor del campo s de la estructura ST.

>> alumno(3)=struct('nombre','Miguel','DNI',323245)
alumno =
nombre
DNI
>> disp(getfield(alumno(3),'nombre'))
Miguel

setfield(ST,s,v)

Cambia el valor del campo s de la estructura ST con el valor de v.

>> alumno(3)=struct('nombre','Miguel','DNI',323245);
>> alumno(3)=setfield(alumno(3),'nombre','Pepe');
>> alumno(3)=setfield(alumno(3),'DNI',1111);
>> disp(alumno(3))
nombre: 'Pepe'
DNI: 1111

MATRICES DE CELDAS (Cell Arrays)

Son matrices en las que el primer elemento puede ser un número, el segundo una matriz, el tercero
una cadena de caracteres, el cuarto una estructura, etc.

cell(m,n)

Crear un Cell Array vacío de m filas y n columnas:
40

>> disp(cell(2,3))
[] [] []
[] [] []

Crear un Cell Array:

CA={[1,2,3],'nombre', rand(2,3)}
CA =
[1x3 double] 'nombre' [2x3 double]

Mostrar el contenido de una celda:

>>CA{1} =
ans=
1 2 3
>> disp(CA{3})
0.9501 0.6068 0.8913
0.2311 0.4860 0.7621

Escribir en una celda:

>> CA(2)={'Antonio'} % o también CA{2}='Antonio'
CA =
[1x3 double] 'Antonio' [2x3 double]

celldisp(CA)

Muestra el contenido de todas las celdas de CA.

>> celldisp(CA)
CA{1} =
1 2 3
CA{2} =
Antonio
CA{3} =
0.9501 0.6068 0.8913
0.2311 0.4860 0.7621

iscell(CA)

Devuelve 1 si CA es un Cell Array.

>> disp(iscell(CA))
1
41


MATRICES DISPERSAS (Sparse Arrays)

Son matrices que contienen una gran cantidad de ceros.

sparse(A)

Crea una matriz dispersa con la matriz llena A.

>> A=[1,0,0,‐1,0;0,2,0,0,1]
A =
1 0 0 ‐1 0
0 2 0 0 1
>> S=sparse(A)
S =
(1,1) 1
(2,2) 2
(1,4) ‐1 % Los dos índices (1,4) indican la fila y la columna, y después el elemento ‐1.
(2,5) 1

sparse(m,n)

Crea una matriz dispersa de m x n con todos los elementos cero.

>> sparse(100,500)
ans =
All zero sparse: 100‐by‐500

speye(m,n)

Crea una matriz identidad dispersa de m x n con unos en la diagonal.

>> disp(speye(3,4))
(1,1) 1
(2,2) 1
(3,3) 1

full(S)

Convierte una matriz dispersa S en una llena.

>> A=[1,0,0,‐1,0;0,2,0,0,1]; S=sparse(A)
42

S =
(1,1) 1
(2,2) 2
(1,4) ‐1
(2,5) 1
>> full(S)
ans =
1 0 0 ‐1 0
0 2 0 0 1

nnz(S)

Devuelve el número de elementos distintos de cero de la matriz dispersa S.

>> A=[1,0,0,‐1,0;0,2,0,0,1]; S=sparse(A);
>>disp( nnz(S))
4

nonzeros(S)

Devuelve un vector que contiene los elementos distintos de cero de la matriz dispersa S.

>> A=[1,0,0,‐1,0;0,2,0,0,1]; S=sparse(A); disp(nonzeros(S))
1
2
‐1
1

spones(S)

Reemplaza por unos los elementos distintos de cero de la matriz dispersa S.

>> A=[1,0,0,‐1,0;0,2,0,0,1]; S=sparse(A);
>> disp(spones(S))
(1,1) 1
(2,2) 1
(1,4) 1
(2,5) 1

issparse(S)

Devuelve 1 si S es una matriz dispersa.

43

>> A=[1,0,0,‐1,0;0,2,0,0,1]; S=sparse(A);
>> disp(issparse(S))
1

PROGRAMACIÓN

if condición
sentencias1
else
sentencias2
end

Si se cumple la condición, ejecuta el bloque sentencias1; si no se cumple, ejecuta el bloque
sentencias2.

A=1;
if A==1
disp('A es uno')
else
disp('A no es uno')
end
B=2;
if B==1
disp('B es uno')
else
disp('B no es uno')
end

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

A es uno
B no es uno

switch expr
case expr1
sentencias
case expr2
sentencias
…..
44

otherwise
sentencias
end

Evalúa expr cuyo resultado debe ser un escalar o una cadena de caracteres. Este resultado se
compara con expr1, expr2… y se ejecutan las sentencias que correspondan con ese resultado; si
no, se ejecutan las sentencias de otherwise.

A=1;
switch A
case 1
disp('A es uno')
case 2
disp('A es dos')
otherwise
disp('A no es uno ni dos')
end
A=2;
switch A
case 1
disp('A es uno')
case 2
disp('A es dos')
otherwise
end
A=3;
switch A
case 1
disp('A es uno')
case 2
disp('A es dos')
otherwise
end

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

A es uno
A es dos
A no es uno ni dos

45

for k=n:step:m
sentencias
end

for k=v % v es un vector con los distintos valores que toma k
sentencias
end

for k=A
sentencias % A es una matriz y k toma en cada iteración el valor de una de la columnas de A
end

Se ejecutan las sentencias comprendidas entre for y end tantas veces como se indica en for.

Primer ejemplo:

for k=1:0.5:2
Y=2*k;
disp(Y)
end

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

2
3
4

Segundo ejemplo:

disp('Vector Y de valores')
for k=[5,6]
Y=2*k;
disp(Y)

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Vector Y de valores
10
12

46

Tercer ejemplo:

disp('Matrices k, Y de valores')
for k=[1,2;3,4]
Y=2*k;
k,Y

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Matrices k , Y de valores
k =
1
3
Y =
2
6
k =
2
4
Y =
4
8

while condición
sentencias
end

Se ejecutan las sentencias comprendidas entre while y end mientras haya elementos distintos de
cero en condición.

A=[1,2,1,1]
while A
disp('No hay ceros en A')
A=[1,0,1,1]
end

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

A =
1 2 1 1
No hay ceros en A
A =
1 0 1 1
47


break

Termina la ejecución del bucle for o while más interno.

for m=1:10
for k=1:0.5:3
y=2*k+m;
disp(y)
if y==5
break
end
end
disp('y=5')
break
end

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

3
4
5
y=5

continue

Pasa a la siguiente iteración del bucle for o while, saltando las sentencias entre continue y el fin
del bucle.

for X=1:‐0.4:‐2
if X<0
continue
end
disp(X)
end

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

1
0.6000
0.2000

48

try
sentencias1
catch
sentencias2
end

Gestiona errores durante la ejecución. Si en el bloque de sentencias1 se produce un error, el
control se transfiere al bloque de sentencias2. La sentencia lasterr() gestiona el error.

V=[1,2]
W=[3,4,5]
try
for X=1:‐0.5:‐2
if X>0
disp(X)
else
V=V+W
end
end
catch
disp('============================================================')
disp('V y W tienen dimensiones distintas')
end
disp('La sentencia ''lasterr'' da el siguiente mensaje:')
disp('=============================================================')
lasterr
disp('=============================================================')
disp('... lasterr('''')pone a cero el contador de errores y devuelve la matriz vacía []')
lasterr('')

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

V =
1 2
W =
3 4 5
1
0.5000
============================================================
V y W tienen dimensiones distintas
La sentencia 'lasterr' da el siguiente mensaje:
============================================================
ans =
49

Error using ==> plus
Matrix dimensions must agree.
============================================================
... lasterr('')pone a cero el contador de errores y devuelve la matriz vacía []

input

Escribe un mensaje en la línea de comandos y espera que el usuario teclee un número o una
cadena de caracteres.

nombre=input('¿Cómo te llamas? ','s'); % s es un parámetro necesario
n=input('Teclee el número de ecuaciones: ');
disp('===================================')
disp('Y las mismas sentencias sin el punto y coma')
nombre=input('¿Cómo te llamas? ','s')
n=input('Teclee el número de ecuaciones: ')

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

¿Cómo te llamas? Pepe
Teclee el número de ecuaciones: 3
===================================
Y las mismas sentencias sin el punto y coma
¿Cómo te llamas? Pepe
nombre =
Pepe
Teclee el número de ecuaciones: 3
n =
3

FICHEROS DE COMANDOS y FUNCIONES. VARIABLES

Un fichero de comandos es un fichero de texto ASCII con extensión (*.m) que contiene comandos
que se ejecutan sucesivamente cuando se teclea su nombre (sin la extensión m). Sus variables son
del espacio de trabajo base, salvo que se emplean en una función, en cuyo caso pertenecen al
espacio de trabajo de la función. Al terminar la ejecución, las variables permanecen en memoria.

Un fichero de funciones es un fichero de texto ASCII con extensión (*.m) que comienza con la
palabra function seguida por los valores de retorno (entre corchetes [] y separados por comas), el
signo igual (=) y el nombre de la función seguido por los argumentos (entre paréntesis y separados
por comas). Su espacio de trabajo es independiente, es decir, aunque varias funciones tengan una
variable llamada A, se trata de variables distintas, a no que ser que A se haya declarado global.

50

%

El símbolo % indica el comienzo de un comentario. Cuando % aparece en la línea de comandos,
todo lo que se escribe desde % hasta el final de la línea es un comentario que no se ejecuta.
También se pueden comentar bloques de sentencias encerrando las líneas entre %{ y %}.

>>nombre=input('¿Cómo te llamas? ','s'); % s es un parámetro necesario
>>n=input('Teclee el número de ecuaciones: ');

echo on, echo off

Escribe (on) o no escribe (off) los comandos de un fichero a medida que se van ejecutando.

echo on
rad= atan(1); disp(rad*180/pi)
echo off
disp('===============')
disp('Ejecución sin echo')
rad= atan(1); disp(rad*180/pi)

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

rad= atan(1);
disp(rad*180/pi)
45
echo off
===============
Ejecución sin echo
45

function [valores de retorno]=nombre(argumentos)

Crea una función.

Ejemplo:
Previamente se ha escrito y guardado en el directorio actual la función funcionsumaproducto.m:

function [suma,producto]=funcionsumaproducto(a,b)
suma=a+b; producto=a*b;

A continuación se ejecuta el fichero de comandos operar.m que llama a la función sumaproducto:

a=input('Introduce el valor de a: ');
51

b=input('Introduce el valor de b: ');
[suma,producto]=funcionsumaproducto(a,b);
disp(['a+b=',num2str(suma)]),disp(['a*b=',num2str(producto)])

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Introduce el valor de a: 2
Introduce el valor de b: 3
a+b=5
a*b=6

global

Declara una variable como global. Las variables globales son visibles en todas las funciones que
las declaran como tales y en el espacio de trabajo base.

>>global A B

clear

Sin argumentos, borra todas las variables excepto las globales.

clear A,i

Borra las variables A, i.

clear functions

Borra las funciones.

clear global

Borra las variables globales.

clear all

Borra todas las variables, incluidas las globales y las funciones.

52

FICHEROS DE DATOS: Lectura y escritura

fopen

Abre un fichero. Su sintaxis es:

[fid,texto]=fopen('misdatos','c')

fid es un número generado por fopen que identifica el fichero (si el fichero misdatos no se
pudiese abrir fid sería –1) y en texto se almacena información sobre un posible error.
En c se escribe r si el fichero se abre para lectura, w si se abre para escritura reemplazando, a si se
abre para escritura añadiendo a continuación, y r+ si se abre para lectura y escritura.

>> [fid,texto]=fopen('misdatos','w')
fid=
3
texto =
''

También se puede hacer sin fid ni texto:

>>disp( fopen('misdatos','w'))
3

fclose

Cierra un fichero. Su sintaxis es:

st=fclose(fid)

fid es el número adjudicado por fopen al fichero y st es un valor de retorno para posibles errores.

>> st=fclose(3)
st =
0

También se puede hacer sin st:

>> fclose(3)
ans =
0

53

fprintf

Escribe en un fichero de manera secuencial (desde el principio hasta el final, sin realizar saltos) en
formato de texto ASCII. Su sintaxis es:

numbytes=fprintf(fid,'cadena de control',var1,var2,…)

En numbytes se devuelve el número de bytes escritos correctamente (puede omitirse); fid es el
número adjudicado por fopen al fichero. La cadena de control, encerrada entre apóstrofos,
contiene el formato de las variables: %s para cadenas de caracteres, %d para variables enteras,
%f para variables de punto flotante y %lf para variables de doble precisión. La cadena de control
puede tener formatos especiales: \n para producir un salto de línea, \r un retorno de carro, \t un
salto de tabulación, \\ para escribir el carácter \, o %% para escribir el carácter %.

x=0:.4:1;Y=[x;exp(x);sqrt(x)]
fid=fopen('datos.txt','w');
numbytes=fprintf(fid,'%2.1f %9.8f %9.8f ',Y)

% Los espacios en blanco son los que se intercalan entre los datos.
% La matriz Y se lee por columnas

fclose(fid);
type datos.txt

x=0:.4:1; y=[x;exp(x);sqrt(x)];
numbytes=fprintf(fid,'%2.1f %9.8f %9.8f\n',y) % Al escribir \n se produce un salto de línea
fclose(fid);
type datos.txt

x=0:.4:1; y=[x;exp(x);sqrt(x)];
numbytes=fprintf(fid,'%2.1f %9.8f %9.8f\r',y) % Al escribir \r se produce un retorno de carro
fclose(fid);
type datos.txt

x=0:.4:1; y=[x;exp(x);sqrt(x)];
fprintf(fid,'%2.1f %9.8f %9.8f\t',y); % Al escribir \t se salta un tabulador. Se ha omitido numbytes
fclose(fid);
type datos.txt

x=0:.4:1; y=[x;exp(x);sqrt(x)];
54

fprintf(fid,'%2.1f %9.8f %9.8f\\',y); % Al escribir \\ se intercala un símbolo \
fclose(fid);
type datos.txt

x=0:.4:1; y=[x;exp(x);sqrt(x)];
fprintf(fid,'%2.1f %9.8f %9.8f%%',y); % Al escribir %% se intercala un símbolo %
fclose(fid);
type datos.txt

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Y =

0 0.4000 0.8000
1.0000 1.4918 2.2255
0 0.6325 0.8944

numbytes =
93
0.0 1.00000000 0.00000000 0.4 1.49182470 0.63245553 0.8 2.22554093 0.89442719

numbytes =
84
0.0 1.00000000 0.00000000
0.4 1.49182470 0.63245553
0.8 2.22554093 0.89442719

0.0 1.00000000 0.00000000
0.4 1.49182470 0.63245553
0.8 2.22554093 0.89442719

0.0 1.00000000 0.00000000 0.4 1.49182470 0.63245553 0.8 2.22554093 0.89442719

0.0 1.00000000 0.00000000\0.4 1.49182470 0.63245553\0.8 2.22554093 0.89442719\

0.0 1.00000000 0.00000000%0.4 1.49182470 0.63245553%0.8 2.22554093 0.89442719%

fscanf

Lee en un fichero de manera secuencial (desde el principio hasta el final, sin realizar saltos) en
formato de texto ASCII y lo guarda en la matriz A. Su sintaxis es:

[A, num]=fscanf(fid,'cadena de control', size)
55


num devuelve el número de elementos leídos correctamente (puede omitirse); fid es el número
adjudicado por fopen al fichero. La cadena de control, encerrada entre apóstrofos, contiene el
formato: %c para cadenas de caracteres, %s para cadenas de caracteres eliminando los espacios
en blanco, %f genera un vector columna. Con size se puede indicar el tamaño de la matriz que se
desea leer (puede omitirse).

x=0:.4:1; y=[x;exp(x);sqrt(x)];
fprintf(fid,'%2.1f %9.8f %9.8f\r',y);
fclose(fid);
type datos.txt

fid=fopen('datos.txt','r');
z=fscanf(fid,'%c') % Se elige uno de los formatos: '%c', '%s', '%f'
fclose(fid);

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Con formato '%c':

0.0 1.00000000 0.00000000
0.4 1.49182470 0.63245553
0.8 2.22554093 0.89442719

z =
0.0 1.00000000 0.00000000
0.4 1.49182470 0.63245553
0.8 2.22554093 0.89442719

Con formato '%s':

z =
0.01.000000000.000000000.41.491824700.632455530.82.225540930.89442719

Con formato '%f':

z =
0
1.0000
0
0.4000
1.4918
0.6325
56

0.8000
2.2255
0.8944

fwrite

Escribe en un fichero de manera secuencial (desde el principio hasta el final, sin realizar saltos) en
formato binario. Su sintaxis es:

num=fwrite(fid,A,precision)

num es el número de elementos de la matriz A escritos correctamente en el fichero; fid es el
número adjudicado por fopen al fichero. Con precision se especifica el tipo de dato seguido de un
número que indica el tamaño en bits.

x=0:.4:1; A=[x;exp(x);sqrt(x)];
fid=fopen('datos.bin','w')
num=fwrite(fid,A,’double’)

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

fid =
3
num =
9

fread

Lee en un fichero de manera secuencial (desde el principio hasta el final, sin realizar saltos) en
formato binario. Su sintaxis es:

A=fread(fid,size,precision)

fid es el número adjudicado por fopen al fichero; size se puede omitir, pero si es n se leen n
elementos en un vector columna, si es inf se lee hasta el final del fichero, si es [m,n] se leen
elementos hasta rellenar una matriz de m x n ordenada por columnas, n puede ser inf, pero m no;
con precision se especifica el tipo de dato seguido de un número que indica el tamaño en bits.

x=0:.4:1; A=[x;exp(x);sqrt(x)];
fid=fopen('datos.bin','w');
num=fwrite(fid,A,'double');
fclose(fid);
fid=fopen('datos.bin','r');
57

B=fread(fid,'double')

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

B =
0
1.0000
0
0.4000
1.4918
0.6325
0.8000
2.2255
0.8944

ftell, fseek, fgetl

En vez de leer o escribir secuencialmente, en un fichero de texto en formato ASCII se puede
acceder directamente a una posición concreta empleando una especie de cursor. La función ftell
indica la posición de dicho cursor, fseek mueve el cursor y fgetl lee el contenido hasta el final de
cada línea.

La sintaxis de ftell es:

posicion=ftell(fid)

fid es el número adjudicado por fopen al fichero. En position se guarda la localización mediante
un número que indica los bytes que hay desde el comienzo del fichero.

La sintaxis de fseek es:

fseek(fid,salto,origen)

fid es el número adjudicado por fopen al fichero; con salto > 0 avanza, salto = 0 no se modifica la
posición y salto < 0 retrocede respecto a la posición indicada por origen; origen es 'bof' o –1 para
indicar el comienzo del fichero, 'cof' o 0 para la posición actual, y 'eof' o 1 para indicar el final del
fichero. La función fseek devuelve 0 si la lectura es correcta y –1 si se produce un fallo.

La sintaxis de fgetl es:

fgetl(fid)

fid es el número adjudicado por fopen al fichero.

58

x=2:3; A=[x;sqrt(x)]
fprintf(fid,'%2.1f %9.8f\r',A); % hay un espacio en blanco . Una matriz se lee por columnas
disp ('==============')
fclose(fid);
fid=fopen('datos.txt','r');
fseek(fid,0,'bof'); % salta al comienzo del fichero
for k=1:2
disp(fgetl(fid)) % lee la línea completa (por columnas)
end
disp ('==============')
for k=0:29
fseek(fid,0,'bof');
fseek(fid,k,0); % salta k bytes desde la posición actual
disp(fgetl(fid))
end
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

A =
2.0000 3.0000
1.4142 1.7321
=============
2.0 1.41421356
3.0 1.73205081
=============
2.0 1.41421356
.0 1.41421356
0 1.41421356
1.41421356 % hay un espacio en blanco delante
1.41421356
.41421356
41421356
1421356
421356
21356
1356
356
56
6
3.0 1.73205081
.0 1.73205081
0 1.73205081
1.73205081 % hay un espacio en blanco delante
1.73205081
59

.73205081
73205081
3205081
205081
05081
5081
081
81
1

SISTEMA OPERATIVO. Comandos

!

Con el símbolo ! se ejecutan comandos del DOS desde la ventana de Matlab. Basta anteponer ! al
comando.

>> !type mifichero.m % Imprime en la pantalla la líneas de mifichero.m

dir

Muestra el contenido de un directorio.

>> dir c:\

what

Muestra los ficheros *.m que hay en el directorio actual.

delete

Borra ficheros.

>> delete mipro*.*
% Borra todos los ficheros cuyo nombre comience por mipro y que tengan cualquier extensión

mkdir

Crea un subdirectorio.

>> mkdir misprogramas % Crea el subdirectorio misprogramas en el directorio actual

60

type

Imprime en la pantalla el contenido de un fichero.

>> type mifichero.m % Imprime en la pantalla la líneas de mifichero.m

cd

Cambia de directorio. Se gestiona igual que en el sistema operativo DOS.

>>cd C:\Matlab

pwd

Muestra el path del directorio actual.

>> disp(pwd)
e:\

which

Localiza un fichero *.m

>> which primosiono
C:\ Matlab\comandos y programas\primosiono.m

DERIVACIÓN, INTEGRACIÓN, RAÍCES DE UNA FUNCIÓN
MÁXIMOS Y MÍNIMOS

diff

Calcula derivadas de manera simbólica. La función se debe ingresar como una cadena de
caracteres.

>>diff('sin(x)') % Función sin(x) definida mediante una cadena de caracteres
ans =
cos(x)
>>disp(diff('sin(x)',2)) % Derivada segunda de sin(x)
‐sin(x)

61

int

Calcula la integral de manera simbólica.

>>disp(int('log(x)')) % Primitiva de la función logaritmo
x*log(x)‐x

quad

Calcula la integral definida entre dos valores de la abscisa. El símbolo @ debe preceder al nombre
de la función.
Ejemplo:

Se crea la función cuadrado:

function y=cuadrado(x)
y=x.^2; % Obsérvese el punto (∙) que precede a ^

Se calcula su integral entre dos valores de x, y se guarda en la variable area:

>> area=quad(@cuadrado,0,3) % Se calcula la integral entre x = 0 y x = 3.
area =
9.0000

Si la función ya existe como tal basta anteponer el símbolo @:

>> area=quad(@sin,0,pi)
area =
2.0000

fzero

Calcula una raíz o cero de una función de una variable. El símbolo @ debe preceder al nombre de
la función.

Ejemplo:
Se crea la función mifuncion:

function y=mifuncion(x)
y=(x‐1)*(x‐2);

Se calcula la raíz más próxima al valor de x introducido o en un intervalo de x:

62

>>disp( fzero(@mifuncion,0))
>> % el valor x = 0 decide cuál es la raíz a calcular
1
>>disp( fzero(@mifuncion,1.5))
>>% el valor x = 1.5 decide cuál es la raíz a calcular
1
>>disp( fzero(@mifuncion,1.6))
>> % el valor x = 1.6 decide cuál es la raíz a calcular
2
>> disp(fzero(@mifuncion,0,1.6))
>> % la raíz debe estar en el intervalo [0,1.6]. Para ello la función debe cambiar de signo
1

fminbnd

Calcula el valor mínimo de una función de una variable. El símbolo @ debe preceder al nombre
de la función.

Ejemplo:
Se crea la función mifuncion:

function y=mifuncion(x)
y=(x‐1)*(x‐2);

Se calcula el valor mínimo correspondiente al intervalo de x introducido:

>> disp(fminbnd(@mifuncion,0,1)) % El valor mínimo del intervalo [0,1]
0.9999
>> disp(fminbnd(@mifuncion,0,2)) % El valor mínimo del intervalo [0,2]
1.5000

Para calcular los máximos basta cambiar el signo de la función.

GRÁFICOS

plot

Crea un gráfico en dos dimensiones a partir de vectores o columnas de matrices, con escalas
lineales en ambos ejes. Se pueden modificar las características de las líneas (ancho, tamaño,
marcas, etc.).
63

5.5
4.5
3.5
2.5
1.5
1
1 1.5 2 2.5 3 3.5 4

>>X=[1,3,2,6];
>>plot(X, 'color','b','LineWidth',2,'MarkerSize',8,'LineStyle','‐','Marker','+')

Se dibujan en ordenadas los elementos del vector X frente a los índices del mismo en abscisas. En
este caso: se unen con una recta los puntos: (1,1), (2,3), (3,2) y (4,6).

La gestión del color es:
Azul (b), amarillo (y), magneta (m), cyan(c), rojo (r), verde (g), blanco (w), negro (k).

Se gestiona el ancho de la línea con LineWidth, el tamaño de las marcas con MarkerSize, el estilo
de las líneas con LineStyle y la marcas con Marker.

>>x=pi*(‐1:0.1:1); y=x.*sin(x);
>>plot(x,y)

Se unen los puntos (x,y) mediante una poligonal.

1.8
1.6
1.4
1.2
0.8
0.6
0.4
0.2
0
-4 -3 -2 -1 0 1 2 3 4

64

>>x=0:pi/25:6*pi; y= sin(x); z=cos(x);
>>plot(x,y,x,z)

Se dibujan gráficas (en este caso dos) con colores distintos siguiendo el orden azul, verde, rojo,
cian, magenta, amarillo y negro.
1
0.8
0.6
0.4
0.2
-0.2
-0.4
-0.6
-0.8
-1
0 2 4 6 8 10 12 14 16 18 20

grid

Dibuja una cuadrícula en una gráfica. Con grid off desaparece la cuadrícula, además plot debe
preceder a grid.

title ('título')

Añade el título a una gráfica.

xlabel('etiqueta')

Añade una etiqueta al eje de abscisas.

ylabel('etiqueta')

Añade una etiqueta al eje de ordenadas.

text(x,y, 'texto')

Añade un texto en el lugar especificado por las coordenadas x e y.

>>X= [1,3,2,6];
>>plot(X)
>>grid
>>title('QUEBRADA'), xlabel('Eje X'), ylabel('Eje Y'), text(2.05,3.25,'VÉRTICE')
65

QUEBRADA
6
5.5
4.5
Eje Y
3.5
VÉRTICE
3
2.5
1.5
1
1 1.5 2 2.5 3 3.5 4
Eje X

loglog

Ídem que plot, pero con escala logarítmica en ambos ejes.

semilogx

Ídem que plot, pero con escala logarítmica sólo en el eje de abscisas.

semilogy

Ídem que plot, pero con escala logarítmica sólo en el eje de ordenadas.

>>X= [1,3,2,6];
>>loglog(X) , grid, title('QUEBRADA')
>>xlabel('Eje X'), ylabel('Eje Y'), text(2.05,3.25,'VÉRTICE')

QUEBRADA ESCALA LOGARÍTIMCA EN EJE DE ORDENADAS ESCALA LOGARÍTIMCA EN EJE DE ABSCISAS
6
5.5
4.5
VÉRTICE VÉRTICE
4
Eje Y
Eje Y
Eje Y
3.5
VÉRTICE
3
2.5
1.5
0 0
10 10 1
0 1 1.5 2 2.5 3 3.5 4 0
10 10
Eje X
Eje X Eje X

hold

Con hold on se respetan los gráficos ya escritos y se añaden otros en la misma ventana. Con hold
off se cancela.
66


>>V= [1,3,2,6]; W=[1,2,3,4]; plot(V)
>>hold on, plot(W)
>>text(1.5,2.2,'V'),text(3,3.2,'W')
6
5.5
4.5
3.5
W
3
2.5
V
2
1.5
1
1 1.5 2 2.5 3 3.5 4

line

Dibuja las líneas que unen los puntos cuyas coordenadas se pasan como argumentos. Como en
plot, se puede gestionar el color, ancho de línea, tamaño de las marcas, estilo de línea, el tipo de
marca, etc.

>> line ([10,15], [20,30],'color','b','LineWidth',2,'MarkerSize',8,'LineStyle','‐','Marker','+')
% Las coordenadas son ([xinicial,xfinal], [yinicial,yfinal]).
30
29
28
27
26
25
24
23
22
21
20
10 10.5 11 11.5 12 12.5 13 13.5 14 14.5 15

67

fplot

Dibuja una función escalar o vectorial introducida como argumento. Su sintaxis general es:

fplot ('función', límites, 'cadena', tol)

donde: 'función' es el nombre de la función o del fichero *.m entre apóstrofos; límites es un
vector de 2 ó 4 elementos cuyos valores son [xmin,xmax] ó [xmin,xmax,ymin,ymax]; 'cadena'
permite controlar, como en plot, el color, las marcas, el tipo de línea, etc. y tol es la tolerancia del
error relativo.

También puede utilizarse fplot con la sintaxis:

[x,y]=fplot ('función', limites, 'cadena', tol)

en este caso se devuelven los valores x e y, pero no se dibuja. El gráfico se obtendría con un
comando plot posterior.

Ejemplo:

Se comienza creando un fichero llamado doscurvas.m que contiene las siguientes líneas:

function y=doscurvas(x)
y(:,1)=200*sin(x)./x;
y(:,2)=x.^2;

a continuación se ejecuta el comando:

>> fplot('doscurvas(x)',[‐20,20],'b')
400
350
300
250
200
150
100
50
-50
-20 -15 -10 -5 0 5 10 15 20

68


fill

Dibuja polígonos planos rellenándolos de un color.

>> x=[1,5,4,2]; y=[1,0,4,3]; fill(x,y,'r')
4
3.5
2.5
1.5
0.5
0
1 1.5 2 2.5 3 3.5 4 4.5 5

ezplot

Dibuja una función explícita, implícita o paramétrica.

>> ezplot('cos(x)') % Por defecto el intervalo de x es [–2π, 2π]
>> ezplot('cos(x)',[‐pi,pi]) % El intervalo de x es [–pi,pi]
cos(x) cos(x)

1 1

0.5 0.5

0 0

-0.5 -0.5

-1
-1

-3 -2 -1 0 1 2 3
-6 -4 -2 0
x
2 4 6
x
69

>> ezplot('x^2 + y^2‐25')
% Dibuja la función implícita x^2 + y^2–25 = 0 en el intervalo [–2π, 2π] tanto para x como para y.

>> ezplot('x^2 + y^2‐25', [‐5,5])
% Dibuja la función implícita x^2 + y^2–25 =0 en el intervalo [–5,5] tanto para x como para y.
x 2 + y 2-25 = 0 x 2 + y 2-25 = 0
5
6
4
4 3
2
2
1
0

y
0
y
-1
-2 -2
-4
-3
-4
-5
-6
-6 -4 -2 0 2 4 6
-5 -4 -3 -2 -1 0
x
1 2 3 4 5
x
>>ezplot('x^2 + y^2‐25',[‐5,5,0,5])
% Dibuja la función implícita x^2 + y^2 –25 =0 en el intervalo [–5,5] para x, y en [0,5] para y.

>> ezplot('sin(t)','cos(t)')
% Dibuja la función paramétrica x(t) = sin(t), y(t)=cos(t) en el intervalo de t [0,2π]
5
x 2 + y 2-25 = 0
1
x = sin(t), y = cos(t)
4.5 0.8
4 0.6
3.5 0.4
3 0.2
2.5 0
y
2 -0.2
1.5 -0.4
1 -0.6
0.5 -0.8
0
-5 -4 -3 -2 -1 0 1 2 3 4 5 -1 -0.5 0 0.5 1
x x
ezpolar

Dibuja una función en coordenadas polares.

>> ezpolar ('cos(theta)') % Por defecto el intervalo de x es [0, 2π]
>> ezpolar ('cos(theta)',[0,pi/2])
70

90 90
1 1
120 60 120 60
0.8 0.8
0.6 0.6
150 30 150 30
0.4 0.4
0.2 0.2
180 180 0
0
210 330
210 330
240 300
240 300
270
270 r = cos(θ)
r = cos(θ)

ezsurf

Dibuja superficies.

ezsurf('sin(x*y)',[‐2,2, ‐2, 2])
% Por defecto los intervalos de x e y son [–2π, 2π]. En este caso [‐2,2] para x, [‐2,2] para y
71

Matlab. Guía Rápida de Sentencias y Comandos. Y en España Se Puso El Sol

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Matlab. Guía Rápida de Sentencias y Comandos. Y en España Se Puso El Sol

Cargado por

Copyright:

Formatos disponibles

Agustín

También podría gustarte