Matlab

MATLAB es un programa de cálculo técnico y científico para el tratamiento de la información a través

de matrices numéricas, es una potente herramienta de cálculo, útil para realizar desde elementales
operaciones aritméticas hasta complejos algoritmos numéricos.
MATLAB posee un sencillo lenguaje de programación propio y puede trabajar con números escalares,
con cadenas de caracteres y con otras estructuras de información más complejas.
Acceso al programa
Para acceder al programa bastará pulsar dos veces en el icono de acceso que aparece en el escritorio.
A continuación, veremos las características básicas del entorno MATLAB donde desarrollaremos
nuestro trabajo.

Acceso directo
La ventana de trabajo
La ventana de trabajo o escritorio aparecerá inmediatamente al comenzar una sesión con la aplicación
MATLAB. La configuración elegida a través de la disposición de diferentes barras y ventanas en la
pantalla nos permitirá trabajar en un entorno similar a cualquier aplicación general del sistema operativo
Microsoft Windows XP.
En la ventana de trabajo, destacan de arriba hacia abajo, los siguientes elementos invariantes:
Barra de títulos, con el nombre del programa.
Barra de menú, con todas las opciones del menú general.
Barra de herramientas, formada por varios iconos de acceso rápido a las opciones más utilizadas del
submenú de ficheros y de edición, muchos de ellos inactivos.
Incluye además, diferentes ventanas propias como:
Ventana de comandos (Command Window), donde escribiremos las instrucciones, y dos ventanas,
superior e inferior, que contienen las pestañas que nos muestran nuestro entorno.
Ventana de espacio de trabajo (Workspace) donde se almacenarán las variables y resultados
presentes en memoria y un listado de los componentes instalados (Launch Pad).
Ventana directorio actual (Current Folder) permite disponer de información acerca del directorio en el
que trabajamos.
Ventana historial (Command History) muestra un listado histórico de las últimas instrucciones
ejecutadas.
En la ventana de comandos cada instrucción se escribe a continuación del prompt (»), que es el
indicador de que MATLAB está preparado para recibir órdenes.

Una vez escrita alguna instrucción siempre es necesario pulsar la tecla enter ( ) para que MATLAB la
ejecute.
Tras realizar determinada operación numérica el sistema responderá creando, en el espacio de trabajo,
una variable de sistema llamada ans en la que almacena el valor numérico obtenido, siempre que
nosotros no hubiésemos creado alguna otra variable para almacenarlo.
Nota: Es importante observar que si tras
una determinada instrucción se escribe
un punto y coma (;) la variable ans no
aparecería en pantalla.
Interacciones del usuario con el espacio de trabajo
Matlab almacena todas las variables de trabajo en una memoria, el cual es conocido como ventana de
trabajo (Workspace)
Who
La instrucción who muestra un listado de las variables definidas en el espacio de trabajo. Esta
información está también disponible de forma visual, en todo momento, en el espacio de trabajo.
>> who
Your variables are:
a ans b y
whos
ofrece un listado de las variables definidas en el espacio de trabajo que incluye información adicional
sobre su nombre, sus dimensiones como matriz, el tamaño que ocupa en número de bytes empleados
y si su clase, es decir, el formato en el cual se almacena.
>> whos
Name Size Bytes Class Attributes
a 1x1 8 double
ans 1x1 8 double
b 1x1 8 double
r 1x1 8 double

clear
Elimina toda la información existente en el espacio de trabajo. Es decir borra de la memoria.
» clear
» clear a b
Elimina dos o varias variables existentes en el espacio de trabajo.
Otras instrucciones
» clc
Limpia la información en la ventana de comandos aunque, no la información almacenada en el espacio
de trabajo.
» clf
Limpia la información gráfica visualizada en la ventana de figuras activa, pero no la cierra.
» close
Cierra la ventana de figuras activa, cuando exista.

MATLAB facilita al usuario la posibilidad de realizar cambios en las instrucciones

previamente introducidas en la ventana de comandos. Por ello, conviene saber que las
teclas de cursor   disponibles en cualquier teclado estándar nos permiten reproducir las
instrucciones realizadas previamente y,   nos permite realizar los cambios deseados
en la instrucción actual evitando tener que rescribirla.

Guardar y recuperar
Veamos cómo salvar y recuperar todo el espacio de trabajo o algunas de las variables creadas en el
mismo. Por su sencillez, bastará emplear dos instrucciones primordiales para realizar esta tarea: save
permite salvar el espacio de trabajo en un archivo (con diversas variantes) y, load permite recuperar el
espacio de trabajo, previamente salvado, en un archivo (con diversas variantes).
» save datos a
Guarda en el directorio desde donde ha sido iniciado MATLAB la variable x en un fichero denominado
datos.mat (utilizando formato binario únicamente comprensible por el entorno MATLAB). Este archivo
se guardará en el directorio hacia donde MATLAB esté direccionado en ese momento.
» save datos w -append
Guarda la variable w a continuación de la información existente en el archivo datos.mat. Esta variante
sólo es aplicable a ficheros con dicha extensión.
» load datos
Recuperaremos, en el formato con que se guardó, las variables contenidas en datos (siempre que
MATLAB se encuentre direccionado hacia el directorio donde se guardó).
Si se desea es posible guardar únicamente ciertas variables de un conjunto más amplio, previamente
contenido en el espacio de trabajo, en archivos específicamente denominados, por ejemplo
» save matrices A B C
Guarda las matrices A, B y C, en un archivo denominado matrices.mat.
También pueden combinarse en dicha lista ambos tipos de variables numéricas, escalares y matrices,
para guardarse en un mismo archivo, en formato .mat. En cualquier caso serán consideradas matrices
de orden nxm .
» save sesion1
Guardar todo el espacio de trabajo con el nombre de sesion1.mat. Para ello, bastará con escribir en la
ventana de trabajo

» save ejemplo.dat area -ascii –double

Guarda la variable area, en formato ASCII y con doble precisión de catorce cifras decimales, en un
archivo con el nombre ejemplo.dat.d
» load ejemplo.dat –ascii
Recupera la información contenida en el archivo datos.dat, forzando a que se reproduzca en este
formato.
Direccionar Matlab
Existen varias formas de direccionar MATLAB hacia un directorio. Una de ellas es usar el comando cd
del sistema operativo MS-DOS:
Cambiar de unidad >> cd unidad:
>>cd c: >> cd d: >> cd e:
» cd datos
Direcciona al directorio indicado, creado previamente en el Explorador.
Otra forma de direccionar es utilizar la instrucción File, que aparece en la parte superior izquierda de la
ventana de comandos, y seleccionar la opción Open File.

Formatos de salida
Todos los cálculos en matlab son realizados usando doble precisión. La forma de aparición del punto
flotante es controlada por el formato de salida.
El formato numérico que MATLAB muestra, por defecto, contiene cuatro cifras decimales. Existen otros
formatos numéricos disponibles. El más importante es el formato numérico de catorce cifras decimales
que es el utilizado internamente por MATLAB para realizar las operaciones de cálculo.
>> format short
>> s
s = 5.8881
>> format short e
>> s
s = 5.8881e+000
>> format long
>> s
s = 5.888123640006212
>> format long e
>> s
s = 5.888123640006212e+000

>> format hex

>> s
s = 40178d704892864e
>> format rat
>> s
s = 3421/581
>> format bank
>> s
s = 5.89

Ejemplo : Resolver 2(1-1/7) Comando Valor

Format short 17.4500
>> format long Format long 17.449999999999999
>> a=2*(1-1/7) Format short e 1.7450e+001
a = 1.714285714285714 Format long e 1.745000000000000e+001
Format short g 17.45
>> format short
Format long g
>> a=2*(1-1/7)
a = 1.7143 Format hex 4031733333333333
Format bank 17.45
Ejemplo : Resolver cos2(π/2) Format + +
Format rat 349/20
>>cos(pi/2)^2
ans = 3.749399456654644e-033 Por defecto MatLab muestra
los resultados por pantalla
>>format rat con cuatro decimales.
>> cos(pi/2)^2
ans = 1/266709378811357100000000000000000

Los formatos adicionales format compact (suprime una línea posterior) y format loose (pone una línea
posterior) controlan por encima y por debajo de la presentación del número.

2.- Dato y variables

2.1.- Tipos de datos
Se denomina dato a cualquier objeto manipulable por el ordenador. Un dato puede ser un carácter
leído de un teclado, información almacenada en un disco, un número que se encuentra en la memoria
central, etc. Los distintos tipos de datos se representan en diferentes formas en el ordenador: por
ejemplo, no se almacena internamente de la misma manera un número entero que un carácter.
Aunque los lenguajes de alto nivel permiten en alguna medida ignorar la representación interna de los
datos, es preciso conocer algunos conceptos mínimos. A nivel de máquina todos los datos se
representan utilizando una secuencia finita de bits. De este hecho ya se deduce que no todos los datos
son representables en un ordenador. La definición de un tipo de dato incluye la definición del conjunto
de valores permitidos y las operaciones que se pueden llevar a cabo sobre estos valores. Cuando se
utiliza un dato en un programa es preciso que esté determinado su tipo para que el traductor sepa
cómo debe tratarlo y almacenarlo. Dependiendo del lenguaje puede o no ser preciso declarar
expresamente en el programa el tipo de cada dato. No todos los tipos de datos existen en todos los
lenguajes de programación. Hay lenguajes más ricos que otros en este sentido. Los tipos de datos
básicos más usuales son:
 Enteros: números pertenecientes a un subconjunto finito de los números enteros.
Ejemplo:
145 -43 -13
 Reales: números pertenecientes a un subconjunto finito de los números reales (constan
de una parte entera y una parte decimal).
Ejemplo:
0.0067 -16.324 4.0

 Lógicos: los dos valores lógicos, VERDADERO (true) o FALSO (false).

  Caracteres: un conjunto finito de caracteres reconocidos por un ordenador
Ejemplo:
Alfabéticos : A B C ... Z a b c ... z
Numéricos : 1 2 3 ... 9 0
Especiales :+−∗/∧.;<>$
2.2.- Estructura de datos
Los tipos de datos vistos en la sección anterior se suelen denominar elementales. Una estructura de
datos o tipo de datos estructurado es un tipo de dato construido a partir de otros tipos de datos.
Como ejemplo se tienen los siguientes:
 Complejos: son datos formados por un par de datos reales y sirven para tratar números
complejos.
EJEMPLO: 2+3i -3+i (i es la unidad imaginaria)

 Cadenas de caracteres: (también llamadas string) son una sucesión de caracteres delimitados
por una comilla (apostrofo) o dobles comillas, según el tipo de lenguajes de programación.
EJEMPLO: ´Esto es una cadena de caracteres’ ’string’ ’123abc’

 Matrices: son conjuntos de datos numéricos organizados para formar una matriz o un vector.
EJEMPLO: vector fila de dimensión 4 [1, 0, 3, 4]
2.3.- Operaciones Aritméticas
Las operaciones aritméticas habituales se representan normalmente mediante los símbolos
siguientes:
Descripción Símbolo
Exponenciación ^
Suma +
Resta -
Multiplicación *
División /
Operadores elementales
2.3.1.- Reglas de Prioridad
Las operaciones aritméticas NO se efectúan siempre en el orden en que están escritas. El orden viene
determinado por las reglas siguientes:
1. Exponenciaciones.
2. Multiplicaciones y divisiones.
3. Sumas y restas.
4. Dentro de cada grupo, de izquierda a derecha. Para cambiar este orden se usan los paréntesis.
5. Si hay paréntesis, su contenido se calcula antes que el resto.
6. Si hay paréntesis anidados, se efectúan primero los más internos.
EJEMPLO: 2 + 3 ∗ 4 = 2 + 12 = 14
(2 + 3) ∗ 4 = 5 ∗ 4 = 20
1/3 ∗ 2 = 0.3333 . . . ∗ 2 = 0.6666
1/(3 ∗ 2) = 1/6 = 0.166666 . . .
2 + 3∧4/2 = 2 + 81/2 = 2 + 40.5 = 42.5
4 ∧3 ∧2 = (4∧3) ∧ 2 = 64∧2 = 4096
2.4.- Operaciones de Comparación
Imprescindibles para verificar condiciones son las expresiones lógicas, es decir, expresiones cuya
evaluación produce un valor lógico. Las más simples son aquellas en las que se comparan dos datos.
Los operadores de comparación actúan entre dos datos, que tienen que ser del mismo tipo, y
producen un resultado lógico: true o false (en MATLAB se equiparan con 1 y 0 respectivamente). Los
operadores de comparación se representan de distintas formas según el lenguaje. Los que se
muestran en la tabla siguiente son los de MATLAB:
Descripción Símbolo
 Igual a ==
No igual a ~=
Menor que <
Mayor que >
Menor o igual que <=
Mayor o Igual que >=

Tabla de operadores de comparación

EJEMPLO:
3<6 true
0>=1 true
’A’==’B’ false

2.5.- Operadores lógicos

Son los que actúan entre dos operando de tipo lógico. Permiten construir expresiones que
representen condiciones más complicadas, como que se verifiquen varias condiciones a la vez, que se
verifique una entre varias condiciones, etc. La representación de los operadores lógicos varía
bastante de un lenguaje a otro. Es estas notas se representaran como en MATLAB:
Descripción Símbolo
Negación ~
Conjunción &
Disyunción |
Tabla operadores lógicos
El primero de ellos, el operador de negación lógica ∼, es un operador unario, es decir, actúa sobre un
solo operando lógico, dando como resultado el opuesto de su valor, como muestra la siguiente tabla:
Descripción Símbolo
true False
false true
Tabla 2.4 Resultados del operador ~
EJEMPLO: (6>10) false ∼ (6>10) true
Los otros dos operadores lógicos actúan siempre entre dos operandos. Los resultados de su
aplicación se muestran en la tabla siguiente:
A B A&B A|B
True True True True
True False False True
False True False True
False false false False
Resultados de los operadores & y |
EJEMPLO: (1<5)&(510) true
(0<) | (0>5) false
2.6.- Funciones intrínsecas
La mayoría de los lenguajes de programación de alto nivel dispone de una serie de funciones pre-
programadas para evaluar las funciones elementales que se usan en Matemáticas (coseno, seno,
arco-tangente, logaritmo, . . . ) y otras utilitarias. Se les conoce como funciones intrínsecas. La
utilización de estas funciones: nombre de la función (argumento/s) donde argumento/s pueden ser:
un número o expresión, variable o expresión de variables
Ejemplo:
Sqrt(2) % para calcular √ 2
log(cos(x/2)) %para calcular ln(cos(x/ 2))
2.7 Orden general de evaluación de expresiones
En una expresión general pueden aparecer operadores de tipo aritmético, de comparación y lógicos,
así como funciones. El orden de evaluación es el que sigue:
Si en una expresión hay paréntesis, lo primero que se evalúa es su contenido. Si hay paréntesis
anidados, se comienza por los más internos. Si hay varios grupos de paréntesis disjuntos, se
comienza por el que esté más a la izquierda.
En una expresión sin paréntesis de agrupamiento, el orden de evaluación es el siguiente:
1. Las funciones. Si el argumento de la función es una expresión, se le aplican estas reglas. Si hay
varias funciones, se comienza por la de la izquierda.
2. Los operadores aritméticos, en el orden ya indicado.
3. Los operadores de comparación.
4. Los operadores lógicos, en el orden antes mencionado.
2.8.- Variables
Una variable es un nombre simbólico que identifica una parte de la memoria en la que se pueden
guardar números u otro tipo de datos. Es un “sitio” en la memoria del ordenador para “guardar”
datos. El contenido de una variable se puede recuperar y modificar cuantas veces se quiera durante
la ejecución de un programa (o a lo largo de una sesión de trabajo de MATLAB). Una variable, en
general, se identifica por su nombre y su tipo. El nombre debe estar formado por letras y números y
comenzar por una letra, aunque normalmente también se admite el uso de ciertos caracteres
especiales. Una variable está asociada a un tipo de datos.
En la mayoría de los lenguajes de programación (por ejemplo FORTRAN o C) es necesario especificar
el tipo de dato que va a contener una variable antes de usarla, declarándolo con las órdenes
específicas. En el lenguaje de programación de MATLAB las variables no necesitan ningún tipo de
declaración y pueden almacenar sucesivamente distintos tipos de datos: enteros, reales, escalares,
matriciales, caracteres, etc. Se crean, simplemente, asignándoles un valor.
VARIABLES
Elemento del algoritmo que posee un valor, conocido por un nombre o identificador y que pertenece a
un tipo definido al inicio del algoritmo.
Matlab no necesita la declaración de variables y basta hacer uso de ellas para que queden declaradas:
>>A=45.6; b=8;
Almacenamiento de variables
b1=cos(2);
K>> b2=sin(2);
K>> save datos a b1 b2
K>> load datos

2.8.1.- Instrucción de asignación

Las instrucciones de asignación sirven para almacenar un valor en una variable. La sintaxis más
habitual de una operación de asignación es:
Variable = expresión
que debe ser interpretada como: evaluar (si es preciso) el resultado de la EXPRESI´ON y almacenarlo
en la dirección de memoria correspondiente a VARIABLE.
El signo = significa “ALMACENAR EN”.
La acción de almacenar un valor en una variable hace que se pierda el valor que, eventualmente,
tuviera dicha variable previamente.
EJEMPLO:
a=2 % guardar en la variable a el valor 2
b=-4 % guardar en la variable b el valor -4
raiz=sqrt(2*b+8*a) % guardar en la variable raiz el valor √ 8
a=a+1 % sumar 1 al contenido de a (guardar 3 en a)

Constantes
Una constante es un dato numérico o alfanumérico que no cambia durante todo el desarrollo del
algoritmo o durante la ejecución del programa. Es un objeto de valor invariable. Para expresar una
constante se escribe explícitamente su valor.
Tipos de Constantes:
Constantes Numéricas (Enteras y Reales)
Constantes Alfanuméricas
Constantes Lógicas (Boolenas)

Las constantes pueden ser:

Constantes sin nombre: Es una expresión numérica donde se puede utilizar directamente el valor.
Constantes con nombre: Se hace una reserva de memoria en la cual se guarda el valor que será
utilizado como constante.
Ejemplo:
a) PI = 3.1416
b) E = 2.718228
c) Iva = 0.13
d) igv=0.18

Variables simbólicas y numéricas

Variables numéricas
Los cálculos en Matlab, por defecto, se realizan en formato numérico. Hay cálculos que se realizan
habitualmente en Matemáticas y que no son posibles con las ordenes de Matlab estudiadas hasta el
momento. Por ejemplo, al efectuar (a + b)(a − b) o R (2x)dx obtendremos un mensaje de error debido
a que las variables a, b, y x no tienen valores asignados. Para solventar este tipo de problemas,
podemos utilizar la herramienta cálculo simbólico de Matlab. A las expresiones sobre las que se realiza
el cálculo simbólico se las denomina expresiones simbólicas y a las constantes y variables que aparecen
en ellas constantes y variables simbólicas.
Cuando en Matlab se quiere trabajar con una variable como tal, ha de definirse como simbólica. En caso
contrario Matlab pediría valores para esa variable y daría un mensaje de error. Si se quiere introducir una
función de forma que la variable x no tome valores concretos hasta cuando se requiera, existe el comando
>>sym, o se declara la variable como simbólica de cualquiera de las dos formas siguientes:
>> x=sym(‘x’) , o bien
>>syms x
De la segunda forma, es posible declarar todas las variables simbólicas en una misma sentencia,
separadas por espacios en blanco. Dar un valor concreto a esta variable para que deje de ser simbólica,
y así conocer el valor numérico del resultado, se realiza con el comando >>double.
Evaluar la función f(x)=x2 -3x+2 en x =2, pi /2.
>>syms x
>>f=x^2-3*x+2;
>>subs(f,2)
ans = 0
>>subs(f,pi/2)
ans = pi^2/16 - (3*pi)/2 + 2
>>double(ans)
ans = 0.2607
El comando >>subs siempre evalúa funciones de tipo simbólico y el resultado que devuelve es
considerado también simbólico. Si se define la función de otra forma, por ejemplo con el comando
>>inline, la instrucción >>subs no funciona; debe evaluarse con su nombre directamente o con el
comando >>feval.
Define la función f(x)=x 2 -3x+2 con inline y evalúala en x =2,0.
>> clear x
>> g=inline('x^2-3*x+2')
g= Inline function:
g(x) = x^2-3*x+2
>> g(2) ans = 0
>>feval(g,0) ans= 0
Matlab siempre guarda en memoria los datos en coma flotante, y por lo tanto redondea dichos
números. Al efectuar operaciones con ellos, el resultado final puede verse afectado.
Definir dos funciones cualesquiera con el comando
>>inline y evaluarlas de forma distinta:
a) >> f=inline('x^2-3*x+2')
f= Inline function:
f(x) = x^2-3*x+2
>> f(2)
ans = 0

b) >> y=inline('x^2+1')
y= Inline function:
y(x) = x^2+1
>> y(1)
ans = 2
>> feval(y,1)
ans =2
Para evaluar funciones definidas mediante >>inline no se puede usar el comando >>subs .
C. Definición de funciones simbólicas definiendo la variable como simbólica
Para evaluar se utiliza el comando >>subs .
>> x=sym('x');p=2*x-5;
>> subs(p,1) ans = -3
D.Definición de función simbólica entre comillas simples En este caso no hace falta declarar la variable.
de nuevo es evaluada con el comando >>subs
>> y='x^2+1';
>> subs(y,0)
ans = 1
Construyase f=ax2+bx+c y sustitúyase x por t. Para a=2, b=1, c=0. Obténgase el valor de f, cuando t=2
y t=[1:4].
>> syms x a b c
>> f=a*x^2+b*x+c
f = a*x^2 + b*x + c
>> syms t
>> g=subs(f,x,t)
g = a*t^2 + b*t + c
>> h=subs(g,{a b c},{2 1 0})
h = 2*t^2 + t
>> u=subs(h,t,2)
u = 10
>> v=subs(h,t,[1:4])
v = 3 10 21 36

Vectores
Los arreglos en MATLAB son fundamentales para almacenar y manipular datos. Un arreglo es una lista
de números ordenados en filas, columnas o ambas. El arreglo más simple (unidimensional) es una fila
o una columna de números. (Montufar, 2014).
Un vector, conocido también como arreglo unidimensional compuesto de una fila y varias columnas
(1xn) o varias filas y una columna (nx1). Los vectores guardan o almacenan datos para su posterior
manipulación mediante operaciones propias de vectores u operaciones matemáticas.
Ejemplo: Temperaturas máximas Juliaca en una semana (04/09/16 a 10/09/16)
Día domingo lunes martes miércoles jueves viernes sábado
Temperatura 16.8 19.6 19.5 20.5 19.9 20.2 19.2
Fuente: Senamhi Puno
Un vector fila de n elementos (1xn) se puede representar de dos formas:
Vector = [v1,v2,v3,…..vn]
Vector = [v1 v2 v3 …..vn]
Ejemplo:
Temperatura = [16.8 19.6 19.5 20.5 19.9 20.2 19.2]
Respuesta = [7 3.21 3.4 7/5 4.25]

Un vector columna de n elementos (nx1) se puede representar de dos formas:

Vector = [v1,v2,v3,…..vn]
Vector = [v1
v2
v3
…..
vn]

Ejemplo:
Temperatura = [16.8;19.6;19.5;20.5;19.9;20.2;19.2]
Temperatura = [
16.8
19.6
19.5
20.5
19.9
20.2
19.2]

Un vector se puede representar sin necesidad de definir sus elementos, es decir mediante una
sucesión con intervalos constantes o con n términos de intervalos constante.
Vector con sucesión de elementos con intervalos constante
Para un vector con el elemento a1(primer elemento) y an (último elemento), la sucesión de elementos
entre a1 y an puede estar distribuido uniformemente entre sí, es representado de dos formas:
Nombre_vector=[a1 : i : an] o
Nombre_vector=a1 : i : an

Ejemplo
Numeros_pares=[2 : 2 : 100]
Numeros_impares=1 : 2 : 100
Numeros_suc_3=[3 : 3 : 100]

Vector con sucesión de elementos con intervalos constantes con n términos

Representar un vector con n términos o n elementos con intervalos constantes entre el primer elemento
y el último elemento, a través de la función linspace con la siguiente sintaxis:
Nombre_vector=linspace(a1, an,n)
Ejemplo:
linspace(2,50,10)
int32(linspace(2,50,10))

Acceso a los elementos de un vector en una posición k

El acceso a los elementos de un vector nos permite cambiar valores, definir sub vectores.
Nombre_vector(posición K)
Ejemplo:
Temperatura = [16.8 19.6 19.5 20.5 19.9 20.2 19.2]
Temperatura(5)
Ans=19.9
 Nombre_vector=[a1 : an] o
Nombre_vector=a1 : an
Nombre_vector=[a1 : i : an] o
Nombre_vector=a1 : i : an
Nombre_vector=linspace(a1, an,n)
Nombre_vector= logspace(a1, an,n)
a1 es el primer elemento y an es el último elemento.
El símbolo : representa el incremento en una unidad
entre cada elemento: a1 a2 a3 a4 … an
a1 es el primer elemento y an es el último elemento.
La secuencia de elementos tienen un incremento de i.
a1 es el primer elemento y an es el último elemento. El
tercer parámetro representa el número de elementos
uniformemente distribuidos entre sí, en el vector.
a1 es el primer elemento y an es el último elemento. El
tercer parámetro representa el número de elementos
logarítmicamente distribuidos entre sí, en el vector.

>> n_pares=[2:2:80];
>> n_impares=[1:2:90];
>> n_vector=linspace(2,40,80);
>> save vec_mat1
>> clear all
>> load vec_mat1
>> size(n_vector)
>> size(n_pares)
>> size(n_impares)

MATRICES
Una matriz es un conjunto de elementos de n filas y m columnas.
𝑎11 𝑎12 … 𝑎1𝑚
𝑎21 𝑎22 ⋯ 𝑎2𝑚
𝐺 = 𝑎31 𝑎32 ⋯ 𝑎3𝑚
⋮ ⋮ ⋱ ⋮
( 𝑎 𝑛1 𝑎 𝑛2 ⋯ 𝑎 𝑛𝑚 )
Los valores de los elementos de las matrices en Matlab se representan entre corchetes, el ingreso de los
elementos de las filas se realiza separando mediante comas o espacios, al término de una fila se separan
mediante punto y coma para iniciar otra fila.
𝐺 = [ 𝑎11 𝑎12 … 𝑎1𝑚 ; 𝑎21 𝑎22 ⋯ 𝑎𝑛2 ; ⋯ ; 𝑎𝑛1 𝑎𝑛2 … 𝑎𝑛𝑚 ]

Ejemplo: Representar la siguiente matriz:

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

Transpuesta de una matriz ( ' ).- Devuelve la transpuesta de una matriz n x m

>> TG=G' %considere la matriz G.
TG =
9 6 3
8 5 2
7 4 1

Obtener el valor numérico de un elemento de una matriz

Nombre_variable = Nombre_matriz(fila, columna)
Obtener el valor del elemento G(2,1)
p=G(2,1)
p=
6

Asignar valor numérico a un elemento de una matriz

Nombre_matriz(fila, columna) = Nombre_variable
Cambiar el valor del elemento G(2,3) por 14
>> G(2,3)=14
G=
9 8 7
6 5 14
3 2 1

Funciones para matrices

Sum(A)- Suma las columnas de una matriz
>> sum(G)
ans =
18 15 22
Diag(A).- Devuelve la diagonal de una matriz n x m.
>> diag(G)
ans =
9
5
1

Size(A).- Devuelve y muestra el tamaño de la matriz

size(G)
ans =
3 3

Matriz identidad de orden n

Eye(n).- Crea una matriz de identidad cuadrática, es decir de tamaño n x n.

>> I=eye(4)
I=
1 0 0 0
0 1 0 0
0 0 1 0
0 0 0 1

Eye(n,m).- Crea una matriz n x m, en donde los elementos de la diagonal principal son 1 y el resto de
elementos de la matriz son 0.
Inm=eye(3,4)
Inm =
1 0 0 0
0 1 0 0
0 0 1 0

Matriz de unos de orden n x m

Ones(n,m) .- Crea una matriz, donde todos los elementos son 1 y tiene tamaño n x m.
>> Unos=ones(2,3)
Unos =
1 1 1
 1 1 1

Matriz nula de orden n x m

Zeros(n,m).- Crea una matriz, donde todos los elementos son 0 y tiene tamaño n x m
>> ceros=zeros(2,3)
ceros =
0 0 0
0 0 0

Matrices aleatorias de orden n x m

Rand(n,m).- Crea una matriz de tamaño n x m, donde los elementos son aleatorios de números
uniformemente distribuidos entre [0,1]
>> M_aleatorio=rand(2,3)
M_aleatorio =
0.8147 0.1270 0.6324
0.9058 0.9134 0.0975

>> M_aleatorio=rand(2,3)*10
M_aleatorio =
7.5127 5.0596 8.9090
2.5510 6.9908 9.5929
>> M_aleatorio=int32(rand(2,3)*10)
M_aleatorio =
8 9 2
2 3 3

Randn normalmente distribuidos

>> t=randn(2,3)
t=
0.8531 -0.7006 1.4600
0.4043 -1.6305 2.0500

>> t=randn(4,3)
t=
0.1205 -0.4698 0.4207
-0.9899 0.8864 0.4007
1.1978 -1.3852 0.0951
-0.5927 -1.9568 0.4967

Randint(n,m,rango).- Crea una matriz de tamaño n x m, donde los elementos generados aleatoriamente
y están distribuidos entre [0,k] o [k1, kn]
>> m_enteros = randint(2,3)
m_nenteros =
1 0 0
0 0 1

>> m_entero_po = randint(2,3,4)

m_entero_po =
2 3 1
1 0 1

>> m_entero_ne = randint(2,3,-4)

m_entero_ne =
0 -3 -2
 0 -2 -1

>> m_entero_po_ne = randint(2,3,[-5 5])

m_entero_po_ne =
-4 5 1
0 -2 -3

Randi(rango, n, m).- crea una matriz con n filas y m columnas con elementos generados entre 1 y el
rango
>> r = randi(8,1,3)
r=
8 8 5

>> r = randi(5,6,1)
r=
2
3
4
3
2
5

>> r = randi(5,7,3)
r=
1 5 5
1 4 4
1 4 3
1 1 1
4 5 2
3 5 1
1 5 1

r = randi([-10 10],10,1)

r=

-5
-8
-7
-5
-2
-9
8
9
0
0

Magic().- Crea una matriz mágica de n x n, en donde la suma de los elementos de cada una de
columnas y filas son iguales, así como la suma de las diagonales.
>> magic(3)
ans =
8 1 6
3 5 7
4 9 2
SUBMATRICES
Sea a la matriz n x m

𝑎11 𝑎12 … 𝑎1𝑚

𝑎21 𝑎22 ⋯ 𝑎2𝑚
𝐺 = 𝑎31 𝑎32 ⋯ 𝑎3𝑚
⋮ ⋮ ⋱ ⋮
𝑎
( 𝑛1 𝑎𝑛2 ⋯ 𝑎𝑛𝑚 )

Si i y j son vectores, entonces A(i,j) nos devuelve la submatriz de la matriz A designada mediante las
filas dadas en i y las columnas en j.
Ejemplo: crear una matriz 3 x 5 y obtener la sub matriz m([1 3] ,[1 3 5])
>> m=randint(3,5,19)
m=
10 18 4 12 18
4 10 9 7 0
8 9 11 6 16

>> m1=m([1 3] ,[1 3 5])

m1 =
10 4 18
8 11 16

SUSTITUCIÓN
En una matriz los elementos pueden ser cambiados de valor o es posible sustituirlos, la sustitución se
realiza de dos maneras:
a.- Sustitución de un elemento A(ai,aj)=k.- Se asigna un valor por el que sustituirá al elemento
seleccionado, indicando la fila y columna de ubicación en la matriz.
En la matriz m1 cambiar el elemento18 por 55
>> m1(1,3)=55
m1 =
10 4 55
8 11 16

b.- Sustitución de una submatriz.A( i, j )n x m=K n x m- Se asigna los elementos a la submatriz

indicando la fila y columna de ubicación en la matriz para .
>> m2=[8 6 3 5 7 9; 1 0 7 2 6 1; 2 0 6 7 4 5; 2 4 5 2 8 6]
M2 =
8 6 3 5 7 6
1 0 7 2 6 1
2 0 6 7 4 5
2 4 5 2 8 9

>> m2(2:4,4:6)=2
m2 =
8 6 3 5 7 6
1 0 7 2 2 2
2 0 6 2 2 2
2 4 5 2 2 2

>> m2(1:2,5:6)=ones()*9

m2 =

8 6 3 5 9 9
1 0 7 2 9 9
2 0 6 2 2 2
2 4 5 2 2 2

>> m2([1 3 4],[1 3])=12

m2 =
12 6 12 5 9 9
1 0 7 2 9 9
12 0 12 2 2 2
12 4 12 2 2 2
Componer Matrices( a partir de filas)
Dadas dos matrices con las mismas filas podemos construir otra matriz resultado de unir ambas en una
sola: [A B]

>> [A([1,3],[1,2]) fix(rand(2)*10)]

ans =
9 7 2 9
9 8 4 5

>>B=[2 5; 3 4]; C=[9 8 7 6;1 0 1 0 ]; [B C]

ans =
2 5 9 8 7 6
3 4 1 0 1 0

Componer Matrices( a partir de Columnas)

Dadas dos matrices con las mismas columnas podemos construir una matriz resultado de colocar una
encima de la otra: [A; B]
>> x=[8 6 8 5 7 9; 1 0 7 2 3 1; 2 0 6 7 4 9; 2 4 5 2 8 6], y=[2 3;0 1], z=[1 0 5 6; 1 0 1 0]
x=
8 6 8 5 7 9
1 0 7 2 3 1
2 0 6 7 4 9
2 4 5 2 8 6

y=
2 3
0 1

z=
1 0 5 6
1 0 1 0

>> [x; y z]
ans =
8 6 8 5 7 9
1 0 7 2 3 1
2 0 6 7 4 9
2 4 5 2 8 6
2 3 1 0 5 6
0 1 1 0 1 0

Matriz vacia

Operador << . >>

Este operador permite hacer operaciones elemento a elemento en una matriz
t=[5 3 1; 2 4 6], u=[7 8 9; 1 4 6]
>> t*u
??? Error using ==> mtimes
Inner matrix dimensions must agree.

>> t.*u
ans =
 35 24 9
2 16 36

Universidad Nacional de Juliaca

Programación para Ingeniería
Practica de laboratorio N° ____

Escuela Profesional : ……………………………………………………………….. Semestre: …………

Apellidos y nombres: …………………………………………………………………………………………

Vectores y Matrices
1.- a=[5,7,1,12;2,9,17,8;15,6,4,12;7,11,5,16]
a=
5 7 1 12
2 9 17 8
15 6 4 12
7 11 5 16

>> sum(a) %suma de columnas

ans =
29 33 27 48

>> a' % transponer una matriz

ans =
5 2 15 7
7 9 6 11
1 17 4 5
12 8 12 16
>> (a')' % doble transposición
ans =

5 7 1 12
2 9 17 8
15 6 4 12
 7 11 5 16

>> diag(a) %obtención de la diagonal de una matriz

ans =
5
9
4
16

>> sum(diag(a)) %suma de los elementos de una diagonal

ans = 34

>> elemento=a(2,3) %acceso a un elemento de una matriz

elemento = 17

>> fila=a(1,:)% Acceso a la fila 1 y a todas las columnas

fila = 5 7 1 12

>> columna=a(:,2) % Acceso a columna 2 y todas las filas

columna =
7
9
6
11

>> a(4,3)=21 %reemplaza/cambiar un valor de elemento

a=
5 7 1 12
2 9 17 8
15 6 4 12
7 11 21 16

a(4,5)=21 % añadir un elemento

a=
5 7 1 12 0
2 9 17 8 0
15 6 4 12 0
7 11 21 16 21

>> a=a(:,1:4) % copiar todas las filas y solo de la columna uno al cuatro
a=
5 7 1 12
2 9 17 8
15 6 4 12
7 11 21 16

>> a(:,3)=[] %mostrar todas las filas y menos la columna tres

a=
5 7 12
2 9 8
15 6 12
7 11 16

>> a=magic(3) %define matriz mágica 3x3

a=
8 1 6
3 5 7
4 9 2

Poner como ejercicio o examen

>> b=a+a' %generar una matriz simétrica
b=
16 4 10
4 10 16
10 16 4

>> c=b*b' %producto de matrices

c=
372 264 264
264 372 264
264 264 372
d=det(c) %determinante de una matriz
d = 10497600

Ejemplo
Se tiene el siguiente sistema de ecuaciones lineales:
x+y+z=2
2x – y + 2z = 7
-3x + 2y - 2z = -9

a.- Representar gráficamente cada sistema de ecuación lineal

[x,y]=meshgrid(-5:0.5:10); Meshgrid.- Esta función coloca líneas de cuadrícula definidas por
>> z=-21-4*x+8*y;
el usuario en gráficos bidimensionales y tridimensionales.
>> surf(x,y,z)
>> z=3.5-1*x+0.5*y; Surf.- Dibuja superficies en 3d
>> surf(x,y,z)

b.- Representar las matrices correspondientes en Matlab

>> a=[1 1 1;2 -1 2; -3 2 -2]

a=
1 1 1
2 -1 2
-3 2 -2

>> b=[2;7;-9]
b=
2
7
-9

c.- Resolver el sistema de ecuaciones.

>> x=a\b
x = 1.0000
-1.0000
2.0000
Otra forma de resolver este sistema es:
>> inv(a)*b
x= 1.0000
-1.0000
2.0000

EJERCICIOS PROPUESTOS
1.- Se tiene los siguientes valores para la matriz A
a.- Obtener los valores de la segunda y la tercera columna
b.- Obtener la diagonal de A
c.- Obtener la transpuesta de A
d.- Añadir un elemento cualquiera en la columna 4 fila 3
e.- Copiar todas las filas y solo de la columna uno al tres
f.- Mostrar todas las filas y menos la columna dos

2.- Se tiene los siguientes valores para la matriz B

a.- Obtener los valores de la segunda y la cuarta columna
b.- Obtener la diagonal de B
c.- Obtener la transpuesta de B
d.- Añadir un elemento cualquiera en la columna 5 fila 4
e.- Copiar todas las filas y solo de la columna uno al cuatro
f.- Mostrar todas las filas y menos la columna cuatro
g.- Obtener la diagonal de A
h.- Obtener la transpuesta de A

3.- Considere el sistema lineal

a.- Representar gráficamente cada sistema de ecuación lineal
b.- Representar las matrices correspondientes en Matlab
c.- Resolver el sistema de ecuaciones

4.- Considere el sistema lineal

a.- Representar gráficamente cada sistema de ecuación lineal

b.- Representar las matrices correspondientes en Matlab
c.- Resolver el sistema de ecuaciones

5.- Considere el sistema linea

Representar gráficamente cada sistema de ecuación lineal
b.- Representar las matrices correspondientes en Matlab
c.- Resolver el sistema de ecuaciones
Cadena de caracteres
Una Cadena de carácter se representa entre comillas simples (‘cadena’)
Funciones de conversión de cadenas
Char(a).- Devuelve una cadena, luego de convertir códigos Ascii a cadena.
>> s=char(41)
s=
)

>> s=char(42)
s=
*

Double(‘a’).- Devuelve Ascii, luego de convertir una cadena a Ascii.

>> double('hola')
ans =
104 111 108 97
Int2str( ).- Convierte un entero o un conjunto de enteros de un vector a cadena de caracteres.
Num2str( ).- Convierte un entero o un conjunto de enteros de un vector a cadena de caracteres.
Str2num().-Convierte una cadena de caracteres o un conjunto de caracteres de un vector en números
enteros
Str2double().- cadena a numero

Funciones sobre cadenas

Blanks(n) devuelve una cadena de n espacios
Eval(s).- evalua un comando
Findstr(s1,s2).- busca s1 en s2
Ischar(s) true si s es una cadena
Isletter(s).- true si es alfabético
Isspace() detecta si un carácter es un espacio en blanco
Lower(s) convierte a minusculaStrcat(s1,s2) concatena s1 y s2
Srtcmp(s1,s2) compara s1 y s2, true si son iguales
Strcmp(s1,s2,n) compara los n primeros caracteres de dos cadenas s1=s2 compara dos cadenas
carácter a carácter.
Strcmpi(s1,s2) compara ignorando la diferencia entre mayúscula y minúsculas
Deblank(s1) elimina los blancos al final de una cadena de caracteres
Upper(s) convierte s a mayusculas
Isletter()detecta si un character es una letra del alfabeto
Isspace() detecta si un carácter es un espacio en blanco

Ejemplos de cadenas

>> cadena1='programacion'
cadena1 = programación

>> cadena2='para ingenieria'

cadena2 = para ingenieria

>> cat(2,cadena1,cadena2)
ans = programación para ingeniería

>>cad1='abcde'
cad1 = abcde

>> c=double(cad1)
c = 97 98 99 100 101

>>size(cad1)
ans = 1 5

>>c=double(c)
c = 97 98 99 100

>> char(c)
ans =abcde

>>cadena=['UNAJ','PROGRAMACION'] % concatenación
cadena =UNAJPROGRAMACION

>> cadena=char('UNAJ1','programar')
cadena = UNAJ1
programar

>> cadena(1,2)
ans = N

>> cadena(2,2)
ans = r

>> disp(['Imprimir en pantalla pi: ' num2str(pi)])

Imprimir en pantalla pi: 3.1416

Tratamiento de números
Ceil(x) Redondea al entero más grande o igual
>> ceil(345.1234)
ans =
346

Fix(x) Redondea al entero más cercano a cero

>> fix(2340.56)
ans =
2340

Floor(x) Redondeo al entero más pequeño o igual

>> floor(2340.56)
ans =
2340

Round(x) redondeo al entero más cercano

>> round(2340.56)
ans =
2341

>> round(2340.49)
ans =
2340

Mod(x,y) Residuo de la división

>> mod(5,2)
ans =
1
Rem(x,y) Residuo de la división entera
>> rem(5,2)
ans =
1

FUNCIONES BÁSICAS
Sqrt(x) raíz cuadrada
Abs(x) valor absoluto
Conj(z) complejo conjugado
Real(z) parte real
Imag(z) parte imaginaria
Angle(z) argumento
Exp(x) exponencial
Log(x) logaritmo natural
Log10() logaritmo decimal
Sin(x)
Cos(x)
Tan(x)
Asin(x) arcoseno
Acos(x) arcocoseno
Atan(x) arcotangente
Rats(x) aprox racional
Sign(x) signo(1 / -1 / 0)

>> c='cadena'
c=
cadena

>> size(c)
ans =
1 6

>> double(c)
ans =
99 97 100 101 110 97

>> nc=abs(c)
nc =
99 97 100 101 110 97

>> char(nc)
ans =
cadena

>> cc=char('UNAJ','Juliaca')
cc =
UNAJ
Juliaca

>> a=char([99 97 115 97])

a=
casa

>> abs('a')
ans =
97

>> abs('a')-abs('A')
ans =
32

>> char(a-32)
ans =
CASA

>> L=['maria';'Jaime';'Luz';'Rosamaria';'Alberto']
??? Error using ==> vertcat
CAT arguments dimensions are
not consistent.

>> L=char('maria','Jaime','Luz','Rosamaria','Alberto')
L=
maria
Jaime
Luz
Rosamaria
Alberto

>> c=[8;7;8;9;10]
c=
8
7
8
9
10

>> tabla=[L , c]
tabla =
maria
Jaime
Luz
Rosamaria
Alberto

>> sc=num2str(c)
sc =
8
7
8
9
10

>> tabla=[L , sc]

tabla =
maria 8
Jaime 7
Luz 8
Rosamaria 9
Alberto 10

Ejercicio Propuesto
Evaluar las siguientes expresiones para el valor de x y mostrar el resultado en formato long,
short y rat.

Ejemplo: Dibujar la función f(x) = xlog(x) en el intervalo [0; 4] y mostrar el resultado en formato
largo
>> x = [0:0.01:3];
>> y = x.*log(x);
>> plot(x,y)
>> grid on
>>title('grafico')
>> text(1,0.65,'y = x log(x)')

Ejercicio propuesto: sea la función f(x) = 2xlog(x) en el intervalo [0; 5] (con incrementos de
0.02) y mostrar el resultado en formato fraccionario y dibujar la función.
>> x = [0: : ];
>>y =
>>
>>
>>

Construir una matriz aleatoria de números entre -10 y 10 de tamaño 3x5

>>a=rand(3,5)
a=
0.8147 0.9134 0.2785 0.9649 0.9572
0.9058 0.6324 0.5469 0.1576 0.4854
0.1270 0.0975 0.9575 0.9706 0.8003

>> round(a*10) % entre -10 y 10

ans =
8 9 3 10 10
9 6 5 2 5
1 1 10 10 8

>>round((rand(3,5)-rand(3,5))*10)
ans =
4 -1 -1 5 0
8 1 1 -3 0
4 -1 -2 0 1

Ejemplo

>> A=round(rand(3,5)*10)
A=
0 3 4 8 8
3 2 9 4 4
4 8 4 8 2

>> A([1 2 3],[1 3 4])

ans =
0 4 8
3 9 4
4 4 8

>>A=[10:-1:1]
A = Columns 1 through 9
 10 9 8 7 6 5 4 3 2
Column 10 1

>> A=round(rand(3,5)*10)
A=
4 8 1 7 5
7 3 1 5 1
8 5 1 2 1

>> A([2:end-1],:)
ans =
7 3 1 5 1

>> A([2:end],:)
ans =
7 3 1 5 1
8 5 1 2 1

>> A=round(rand(3,5)*10)
A=
9 7 9 9 5
6 6 10 6 5
9 8 0 10 8

>> A(:,[1:2:end])
ans =
9 9 5
6 10 5
9 0 8

Ejercicios

1.- Dibujar la función y = xsin(1/x)+x3 en el intervalo [0;3] (con incrementos de 0.02) y mostrar
el resultado en formato largo y dibujar la función.

2.- Resolver (y mostrar los resultados en tres formatos diferentes) y graficar las funciones:
f(x)=x; f(x)= x2; f(x)= x3
Para un intervalo x=[-3,3]

3.- Obtener el resultado de la expresión:

Mostrar el resultado en formato corto