Manual Matlab FIEE UNI PDF

Colección G UÍAS P RÁCTICAS
MAT L A B
Aplicado a Métodos Numéricos e Ingeniería
MatLAB: Aplicado a los Métodos Numéricos e Ingeniería
Autor: Hider Pimentel Dextre
© Derecho de autor reservado
© Derecho de edición, arte gráfico y diagramación reservados

Empresa Editora Macro E.I.R.L.
Edición a cargo de:

Empresa Editora Macro E.I.R.L.
Av. Paseo de la República N° 5613 - Miraflores
Lima - Perú
(511) 719 - 9700
ventas@editorialmacro.com
www.editorialmacro.com
Primera edición: Marzo 2012 - 1000 ejemplares
Impresión
Talleres Gráficos de la Empresa Editora Macro E.I.R.L.
Lima - Perú
ISBN Nº
Hecho el Depósito Legal en la Biblioteca Nacional del Perú Nº
Prohibida la reproducción parcial o total, por cualquier medio o método de este

libro sin previa autorización de la Empresa Editora Macro E.I.R.L.
Índice Índice
Índice
ÍndiceÍndiceIndice Índice
Índice
Capítulo 1: Introducción
El GUI de Matlab..........................................................................................................9
Ingreso de Datos...........................................................................................................10
Tipos de Datos..............................................................................................................13
Datos Numéricos.........................................................................................................................13
Números Reales...........................................................................................................................13
Números Complejos....................................................................................................................14
Números Enteros.........................................................................................................................15
Conversión de Tipo de Datos.......................................................................................................16
Valores Especiales.......................................................................................................................16
Funciones de Identificación de Tipo de Dato..............................................................................17
Cadenas de Caracteres................................................................................................................17
Comparación de Cadenas............................................................................................................18
Conversión de Valores Numéricos a Cadenas y Viceversa...........................................................20
Tipos de Formato de Salida.........................................................................................................22
Capítulo 2: Operaciones con Matrices y Vectores

Matrices.......................................................................................................................25
Matriz de Números Complejos....................................................................................................25
Matriz Nula..................................................................................................................................26
Definición de Vector....................................................................................................................27
Operador Paso (:).......................................................................................................................27
Reconocimiento de los Elementos de una Matriz.......................................................................27
Matrices Especiales.....................................................................................................................29
Función Generador de Vectores..................................................................................................32
Funciones Para el Análisis de una Matriz....................................................................................32
Operadores y Funciones Matemáticas........................................................................................42
Operadores Aritméticos..............................................................................................................42
Operadores Relacionales.............................................................................................................43
Operadores Lógicos.....................................................................................................................44
Funciones Relacionales y Lógicas Adicionales.............................................................................44
Funciones Matemáticas...............................................................................................................45
Funciones de Fecha y Hora..........................................................................................................47
Operaciones con Funciones.........................................................................................................48
Ejercicio de aplicación.................................................................................................................49
Indexación de Matrices...............................................................................................................51
Concatenación de matrices (Agrupación)...................................................................................53
Ejercicios propuestos....................................................................................................54
Ejercicios más avanzados..............................................................................................55
Capítulo 3: Programación en Matlab

M-FILES........................................................................................................................57
Funciones de Ingreso y Salida de datos.........................................................................61
Sentencias de Control de Flujo......................................................................................64
if … else … end.............................................................................................................................65
if … elseif … else … end................................................................................................................66
switch … case … otherwise … end...............................................................................................68
while … end.................................................................................................................................69
for … end.....................................................................................................................................70
Sentencias Especiales..................................................................................................................71
Ejercicios de Aplicación.................................................................................................72
Ejercicios Propuestos....................................................................................................73
Capítulo 4: Gráficos
Ventana de Figura.........................................................................................................75
Funciones de Gráficas en 2 Dimensiones.......................................................................76
Graficas en 2D..............................................................................................................77
Puntos.........................................................................................................................................77
Cartesianas..................................................................................................................................80
Paramétricas................................................................................................................................82
Polares.........................................................................................................................................83
Quiver..........................................................................................................................................84
Gráficos Múltiples........................................................................................................85
Subplot........................................................................................................................................86
Funciones de Gráficas en 3 Dimensiones.......................................................................88
Puntos.........................................................................................................................................88
Cartesianas..................................................................................................................................89
Paramétricas................................................................................................................................90
Superficies....................................................................................................................91
Forma z=f(x,y)..............................................................................................................................91
Sombras y Colores.......................................................................................................................92
Rotación de Gráfica.....................................................................................................................93
Superficies Complejas.................................................................................................................93
Estadísticas..................................................................................................................................94
Superficies: Generados por Funciones..........................................................................94
Esfera...........................................................................................................................................94
Vectores Normales a una superficie............................................................................................95
Cilindro........................................................................................................................................95
Geometría diferencial de curvas...................................................................................96
Longitud de arco..........................................................................................................................96
Vectores tangente, normal y binormal: Triedro de Frênet-Serret...............................................96
Curvatura y torsión......................................................................................................................97
Plano osculador...........................................................................................................................98
Centro de curvatura....................................................................................................................99
Teorema fundamental de curvas.................................................................................................99
Capítulo 5: Polinomios
Definición.....................................................................................................................103
Operaciones con Polinomios.........................................................................................105
Ejercicios......................................................................................................................108
Ajuste de Curvas Bidimensionales ................................................................................108
Funciones de Interpolación...........................................................................................109
Ejercicios......................................................................................................................111
Capítulo 6: Interpolación
Polinomios de Lagrange ...............................................................................................113
Polinomio de Interpolación por Diferencias Divididas de Newton.................................115
Capítulo 7: Resolución de Sistema de Ecuaciones Lineales

Definición.....................................................................................................................119
Aplicación a los Circuitos Eléctricos...............................................................................121
Operaciones Elementales de Reglón.............................................................................122
Eliminación Gaussiana................................................................................................................122
Metodo de Gauss – Jordan..........................................................................................................124
Pivote Máximo............................................................................................................................125
Método Montante.......................................................................................................................126
Matriz Inversa..............................................................................................................127
Metodos Iterativos: Jacobi............................................................................................127
Métodos Iterativos: Gauss-Seidel..................................................................................129
Capítulo 8: Solución de Ecuaciones No Lineales

Definición del Problema...............................................................................................133
Método de la Bisección.................................................................................................133
Ejercicio propuesto......................................................................................................................136
Método de Punto Fijo (iteración simple).......................................................................136
Método de Newton-Rapson..........................................................................................139
Método de la Secante...................................................................................................141
Newton-Rapson para Funciones de más de una Variable..............................................143
Ejemplo de dos variables.............................................................................................................144
Ejercicios propuestos....................................................................................................145
Capítulo 9: Integración
Método de los Trapecios...............................................................................................148
Método de Romberg.....................................................................................................149
Método de Simpson 1/3...............................................................................................150
Método de Simpson 3/8...............................................................................................152
Funciones de Cuadratura..............................................................................................153
Capítulo 10: Solución de Ecuaciones Diferenciales Ordinarias

Método de Euler...........................................................................................................155
Método de Euler Modificado........................................................................................157
Método de Runge Kutta................................................................................................159
Funciones Ode..............................................................................................................160
Solución de Ecuaciones Diferenciales de Orden Superior..............................................164
MatLAB
El presente manual: MATLAB Aplicado a los Métodos Numéricos e Ingeniería está
orientado a todos los interesados, estudiantes y profesionales de las diferentes
especialidades, en desarrollar la capacidad de manejo de la herramienta MATLAB.
Tiene un enfoque, principalmente, a la adecuación y familiarización del programa
con el usuario. Y al ser la eficiencia en la resolución de problemas matemáticos
la principal característica de esta herramienta, este manual proporciona los
siguientes temas: una introducción al ambiente de trabajo del MATLAB, tipos de
datos, entrada y salida de datos, el manejo y visualización de variables, creación
de m-files, estadística básica, programación utilizando la sentencias de control
de flujo, el desarrollo de visualizaciones gráficas, la aplicación a los Métodos
Numéricos, así como ejemplos directos de aplicación a la ciencia e ingeniería.
Al ser una herramienta de un lenguaje de muy alto nivel, fácil de aprender y
usar, muy potente, flexible, extensible, de gran exactitud, robusto y rápido. No
predispone como requisito necesario el conocimiento de algún otro tipo de lenguaje
de programación, pero si es de su conocimiento aceleraría el estudio del programa.
Dentro de este manual encontraremos un conjunto de herramientas (grupo
de funciones con propósito de aplicación directa) que nos permitirán resolver
problemas diversos mucho más rápidos y eficientes, comparados con otro lenguaje
tales como FORTRAN, C/C++ e inclusive JAVA.
Al finalizar el uso de este manual el lector podrá ser capaz de interpretar todo
tipo de expresión de cálculo al lenguaje MATLAB, además de poder implementar
estructuras de código para solucionar problemas con una metodología adecuada
que podemos describir de la siguiente manera: Planteamiento claro del problema,
descripción de las información de entrada y salida, resolución del problema de
forma manual para ciertos conjuntos de datos sencillos, implementación de una
solución en MATLAB, comprobación de la solución ingresando datos distintos.
Espero que este manual didáctico pueda servir como guía tanto a los programadores
expertos como para principiantes, pero sobretodo que sea un medio de difusión
para lograr el interés de la comunidad académica en esta herramienta sofisticada
que actualmente se dispone.
1
Capítulo
Introducción
En esta parte presentamos al entorno de manejo de Matlab para su mejor adaptación, como un
entorno interactivo para realizar análisis de datos, cálculo numérico y de visualización gráfica. También
se explicará cómo pueden representarse los datos y comandos para imprimir información. En las
primeras secciones comenzaremos explorando Matlab de la forma más simple, en modo comando: el
usuario pregunta y Matlab responde.
El GUI de Matlab
El software se desarrolló originalmente como un ‘Laboratorio de Matrices’, de ahí su nombre, y
actualmente cuenta con una capacidad superior debido a su lenguaje de programación para cómputo
científico y técnico en general.
La siguiente figura define la interfaz gráfica para la versión r20011b:
Cuando se instala el programa, en este caso se realizó en el sistema operativo Windows 7, este por
defecto crea una carpeta de nombre MATLAB en el directorio Documentos, y es ese lugar donde por
defecto el programa almacenará todo archivo creado.
9
Capítulo 1
La Ventana de Comandos (Command Window): Es el espacio principal de interacción entre el usuario

y el software, ahí se ejecutan las instrucciones y muestran los resultados. Mantiene las mejoras de
la versión anterior, algunas de las cuales recordaremos a continuación:
• S e permiten líneas de comandos muy largas que automáticamente siguen en la línea siguiente
al llegar al margen derecho de la ventana. Para ello hay que activar la opción Wrap Lines, en el
menú File/Preferences/Command Window.
• Haciendo clic con el botón derecho sobre el nombre de una función que aparezca en esta ventana
se tiene acceso a la página del Help sobre dicha función.
• Al iniciar la escritura de una función y pulsando la tecla Tab, el programa completa automáticamente
el nombre de la función, o bien muestra un menú de todas las funciones disponibles que comienzan
con las letras digitadas.
• Cuando al ejecutar un fichero *.m se produce un error y se obtiene el correspondiente mensaje
en la Command Window, MATLAB muestra mediante un subrayado un enlace a la línea del
fichero fuente en la que se ha producido el error. Haciendo clic en ese enlace se va a la línea
correspondiente del fichero por medio del Editor/Debugger.
Ventanas auxiliares: command history, workspace, current directory, que informan sobre (y permiten
editar) los comandos insertados, las variables declaradas y el directorio en el que estamos trabajando.
Ventana de ayuda: Es una ventana independiente que proporciona un acceso completo a las funciones
de ayuda de Matlab, incluyendo búsquedas, demostraciones, etc.
Estas son las características básicas que debemos considerar:
• E l prompt de Matlab es >>. El usuario escribe a continuación y para ejecutar se pulsa la tecla
Enter.
• Se pueden recuperar comandos anteriores navegando con las flechas ↑ y ↓.
Ingreso de Datos
Todo dato ingresado al programa es un ordenamiento en filas y columnas, matemáticamente conocido
como matriz y que se define como arreglo en la programación. Y mantiene la siguiente estructura de
sentencia:
>> variable = valor;
Donde:
variable: Es la combinación de caracteres alfabéticos, numéricos y el carácter especial (_), siendo
la cantidad de 63 caracteres como agrupamiento máximo para nombrarla teniendo en cuenta que
los caracteres minúsculos y mayúsculos se diferencian. Las únicas restricciones para nombrar a una
variable son que esta no debe iniciar con un carácter numérico ni el especial (_) y tampoco ser igual
a una palabra reservada.
10
Guía Práctica MatLAB
Ejemplo:
a1, dato, data, f1  variables validas
media23 es diferente a meDia23
1p, 45va, _p1, 3w1  variables invalidas
Las palabras reservadas son las siguientes:

>>iskeyword
ans =
‘break’
‘case’
‘catch’
‘classdef’
‘continue’
‘else’
‘elseif’
‘end’
‘for’
‘function’
‘global’
‘if’
‘otherwise’
‘parfor’
‘persistent’
‘return’
‘spmd’
‘switch’
‘try’
‘while’
valor: Es un dato o un conjunto de datos ordenados en filas y columnas. Por defecto los datos
toman el tipo double, y se puede cambiar de tipo definiéndolo según la necesidad del usuario (ver
ejemplos).
“;”: Es la sentencia de la instrucción. Si una expresión termina en este signo su resultado se calcula,
pero no se muestra en pantalla, y si se omite, entonces el programa ejecutará la tarea y además
mostrará el resultado.
Se define que los valores ingresados al programa pueden Tipo Bytes
ser de los siguientes tipos (se detallará en el siguiente
ítem): doublé 8B
int 4B
char 2B
logical 1B
11
Capítulo 1
Ejemplos:
Ingrese los siguientes datos:
double:
>> x = 7;
int:
>>a = int16(23);
char: Los caracteres deben estar entre apóstrofes.

>> c = ‘hola mundo’;
logical: Son los resultados de una comparación o relación que en programación se define como 0
(falso) y 1 (verdadero).
>> m = 6>4;
Nota
La función who y whos, nos permite ver las variables creadas hasta el momento y a las variables con
sus características de ingreso, respectivamente que están almacenados en el workspace.
>> who
Your variables are:
a c m x
>> whos
Name Size Bytes Class Attributes
a 1x1 2 int16
c 1x10 20 char
m 1x1 1 logical
x 1x1 8 double
Si deseamos ver las características de una o de sólo algunas variables, entonces especificamos ellas
de la siguiente manera:
>> whos a m
a 1x1 2 int16
m 1x1 1 logical

12
Tipos de Datos
Los tipos de datos definidos son de dos clases: numéricos y las cadenas de caracteres.
Datos Numéricos
Números Reales
Matlab representa los números reales en doble precisión y en simple precisión.
a D oble Precisión: double
Es el tipo por defecto de un dato ingresado al programa. A continuación se muestra la creación,
conversión y los valores máximos y mínimos de un dato de doble precisión:
>> d = 45.78;
>> whos d
d 1x1 8 double
La función isfloat nos permite verificar si el dato ingresado es de punto flotante (decimal).
>> d1=isfloat(d)
d1 =
1
Las funciones realmax y realmin devuelven el valor máximo y mínimo para el tipo de doble
precisión.
>> realmax
ans =
1.7977e+308
>> realmin
ans =
2.2251e-308
b Simple Precisión: single

Estos tipos de datos son creados de la siguiente manera:
>> s=single(78.012);
>> whos s
s 1x1 4 single
>> s1=isfloat(s)
s1 =
1
13
Capítulo 1
Las funciones realmax y realmin devuelven el valor máximo y mínimo para el tipo de simple
precisión si es que especificamos el argumento ‘single’.
>> realmax(‘single’)
ans =
3.4028e+038
>> realmin(‘single’)
ans =
1.1755e-038
Números Complejos
Se conoce que los números complejos se definen como un valor que tiene parte real y parte imaginaria.
Donde la base imaginaria es i=√(-1) y que en el programa se define con el carácter i ó j.
Existen 2 formas de ingresar un dato complejo:
La primera es digitar la expresión a+bi.
>> c = 7-15i
c =
7.0000 -15.0000i
La segunda forma es utilizando la función complex de la siguiente manera:

>> z = complex(12,8)
z =
12.0000 + 8.0000i
Podemos obtener los valores numéricos de la parte real e imaginaria de un número complejo ya
ingresado al programa con las funciones real e imag y si queremos conocer su módulo y argumento
en radianes utilizaremos las funciones abs y angle, respectivamente.
>> zr=real(z)
zr =
12
>> zi=imag(z)
zi =
8
>> modulo_z=abs(z)
modulo_z =
14.4222
>> argumento_z=angle(z)
argumento_z =
0.5880
14
Estos datos tendrán un atributo característico de complex, según se puede observar si visualizamos
a las variables en el workspace.
>> whos z c
c 1x1 16 double complex
z 1x1 16 double complex
Nota
Las funciones real, imag, abs y angle, son aplicables también a un arreglo de datos
(matriz de datos).
Números Enteros
Definimos un dato entero como aquel valor exacto dentro del programa. La siguiente tabla muestra
cómo definir los datos enteros:
Tipo Función Rango de Valores

Entero con signo de 8 bits int8 -27 a 27 -1
Entero sin signo de 8 bits uint8 0 a 28 -1
Ejemplos de ingreso de datos enteros:

>> x=int8(23);
>> y=int16(46);
>> w=int64(-6);
>> z=int32(157);
>> whos x y w z
w 1x1 8 int64
x 1x1 1 int8
y 1x1 2 int16
z 1x1 4 int32
15
Capítulo 1
Si se desea verificar si un dato es de tipo entero, utilizaremos la función isinteger:

>>isinteger(x)
ans =
1
>> isinteger(y)
ans =
1
Conversión de Tipo de Datos

Conocidos los tipos de datos, es posible cambiar de un tipo a otro tal como mostraremos a continuación:
>> a=int16(24);
>> b=double(a);
>> c=single(a);
>> whos a b c
a 1x1 2 int16
b 1x1 8 double
c 1x1 4 single
Valores Especiales
La herramienta MATLAB considera los siguientes valores especiales inf, -inf y NaN, para
representar a las cantidades infinito positivo, infinito negativo y a todos aquellos que no son un
número, respectivamente. Verifique los resultados dados a continuación:
>> x=45^245
x =
Inf
>> x=log10(0)
x =
-Inf
>> x=0/0
x =
NaN
>> x=inf/inf
x =
NaN
16
La siguiente tabla muestra algunos valores especiales:

Sintaxis MatLab Significado
pi π
iój √(-1)
inf ∞
NaN No es un número
Funciones de Identificación de Tipo de Dato

Mostramos a continuación una tabla de funciones que nos permiten conocer los tipos de datos
ingresados al programa. Sea x un ordenamiento, entonces:
Función Descripción
whos x Muestra la característica del dato x.
isnumeric(x) Determina si el dato x es un tipo de dato numérico.
Determina si x es un tipo de dato numérico específico, donde arg puede
isa(x, ’arg’) tomar los siguientes textos: integer (entero), uintxx (no entero de xx: 8,
16, 32 ó 64), float, doublé o single.
isreal(x) Determina si el tipo de dato x es un número real.
isnan(x) Determina si el tipo de dato x no es un número.
isinf(x) Determina si el valor de x es infinito.
isfinite(x) Determina si el valor de x es finito.
Cadenas de Caracteres
Una cadena de texto se define como un ordenamiento o arreglo de caracteres UNICODE.

Para crear una cadena al valor de la instrucción se debe encerrar entre comillas simples, por ejemplo:
>> cadena = ‘Bienvenidos al Matlab 2011’
cadena =
Bienvenidos al Matlab 2011
>> whos cadena

cadena 1x26 52 char
17
Capítulo 1
Las funciones class e ischar identifican si un dato es un arreglo de caracteres:

>> m = class(cadena)
m =
char
>> n = ischar(cadena)
n =
1
Es posible la agrupación de 2 o más cadenas de caracteres, para ello utilizaremos la función strcat,
como veremos a continuación:
>> nombre = ‘Jose’;
>> apellido = ‘Manrique’;
>> completo = strcat(nombre,apellido)
completo =
JoseManrique
Para crear una matriz de 2 ó más filas de caracteres debemos tener en cuenta que cada cadena debe
tener la misma cantidad de caracteres. Se debe rellenar con espacios en blanco a las cadenas más
cortas para forzar que sean del mismo tamaño.
Ejemplo:
>> nombres=[‘Jose Carlos’;’Rosario ‘;’Bartolomeo ‘]
nombres =
Jose Carlos
Rosario
Bartolomeo
La manera más simple para crear matriz de cadenas de texto es usando la función char. Esta función
rellena automáticamente a las cadenas de menor longitud para igualar a la cadena de mayor longitud.
Ejemplo:
>> nombres=char(‘Jose Carlos’,’Rosario’,’Bartolomeo’)
nombres =
Jose Carlos
Rosario
Bartolomeo
Comparación de Cadenas
Las cadenas de texto también pueden compararse y esta se realiza carácter con carácter. La siguiente
tabla muestra las funciones con las que se pueden realizar dicha comparaciones:
strcmp Determina si dos cadenas son idénticas. Diferencia las mayúsculas y
minúsculas.
18
strncmp Determina si los n primeros caracteres de dos cadenas son idénticas.

Diferencia las mayúsculas y minúsculas.
strcmpi Determina si dos cadenas son idénticas. No diferencia las mayúsculas y
minúsculas.
strncmpi Determina si los n primeros caracteres de dos cadenas son idénticas. No
diferencia las mayúsculas y minúsculas.
Recordemos que los resultados de una comparación tiene como resultado los valores de 1 (verdadero)
ó 0 (falso).
>> cad_1=’masa’;
>> cad_2=’mazo’;
>> c1=strcmp(cad_1,cad_2)
c1 =
0
Como los primeros 2 caracteres de ambas cadenas anteriores son iguales, entonces podemos realizar
la comparación siguiente:
>> c2=strncmp(cad_1,cad_2,2)
c2 =
1
c3=strncmp(cad_1,cad_2,3)
c3 =
0
También podemos comparar cadenas utilizando los operadores relacionales, siempre que dichas
cadenas tengan iguales dimensiones, o uno sea escalar.
Ejemplo:
>> A=’Rodrigo’;
>> B=’Roberto’;
>> C = A==B
C =
1 1 0 0 0 0 1
La función isletter determina si un carácter es una letra.

>> dia = ‘MatLab 2011b’;
>> str = isletter(dia)
str =
1 1 1 1 1 1 0 0 0 0 0 1
19
Capítulo 1
Conversión de Valores Numéricos a Cadenas y Viceversa
En algunos casos es necesario el cambio de tipo de dato para facilitar la salida en pantalla de
combinaciones de números y caracteres. La tabla siguiente muestra las funciones que hacen posible
algunas conversiones:
Comando Descripción
char Convierte un entero positivo a su equivalente carácter (código ASCII). Trunca
cualquier parte fraccional.
int2str Convierte un valor numérico de tipo int a un dato de tipo char (carácter).
num2str y Convierte un valor numérico de tipo double a un dato de tipo char (carácter) de
str2num precisión con formato específico y viceversa, respectivamente.
mat2str y Convierte un tipo numérico a una de tipo carácter de una determinada
str2mat precisión, retornando una cadena Matlab que puede ser evaluada y viceversa,
respectivamente.
dec2hex y Convierte un entero positivo a un dato de tipo char de base hexadecimal y
hex2dec viceversa, respectivamente.
dec2bin y Convierte un entero positivo a un dato de tipo char de base binaria y viceversa,
bin2dec respectivamente.
dec2base Convierte un entero positivo a un dato de tipo char de cualquier base de 2 a 36.
A continuación, mostramos algunas formas de usar las funciones definidas:

>> M=[77 65 84 76 65 66 50 48 49 49 66];
>> Mc=char(M)
Mc =
MATLAB2011B
Realizando lo contrario:
>> newM=int8(Mc)
newM =
77 65 84 76 65 66 50 48 49 49 66
>> enteros=[ 23 34 11];

>> cadena=int2str(enteros)
cadena =
23 34 11
>> num=[23.5 56 -0.34];

>> cad=num2str(num)
cad =
23.5 56 -0.34
20
>> newnum=str2num(cadena)
newnum =
23 34 11
>> d=[123 37 98];

>> h=dec2hex(d)
h =
7B
25
62
>> newd=hex2dec(h)
newd =
123
37
98
>> b=dec2bin(d)
b =
1111011
0100101
1100010
21
Capítulo 1
Tipos de formato de salida
Matlab tiene forma específica y diferente de visualizar sus datos en el command window. La siguiente
tabla nos muestra estos tipos:
Tipo Descripción
short Formato con 4 cifras significativas exactas.
short e Formato de 5 dígitos. Incluye potencia de 10.
short g Formato de 5 dígitos.
long Formato de 15 cifras significativas exactas.
long e Formato de 15 dígitos. Incluye potencia de 10.
long g Formato de 15 dígitos.
Rat Formato en fracción irreductible.
Hex Formato en base 16 (hexadecimal).
Bank Formato de 2 cifras significativas exactas.
Compact Formato que suprime el exceso de líneas.
Loose Formato que añade más líneas para que sea más legible.
Por defecto el tipo de formato del Matlab es el short, para cambiar a un diferente tipo de formato
podemos usar la función format, estos cambios sólo afectan la forma en la que los números son
visualizados y no como el programa los calcula.
El cambio de formato lo realizamos así:
>> format tipo
Ejemplo:
>> x=[26/14 3 16.567246 4e-4];

>> format short
>> x
x =
1.8571 16.5672 0.0004
>> format long

>> x
x =
1.857142857142857 16.567246000000001 0.000400000000000
>> format rat

>> x
22
x =
13/7 2833/171 1/2500
>> x
x =
1.86 16.57 0.00
Para volver al formato por defecto bastaría con sentenciar la función format.
Nota
Para representar las potencias del número diez, Matlab abrevia la forma de su
definición utilizando la forma exponencial.
Entonces:
104  1e4 ó 5×10-7  5e-7
23
2
Capítulo
Operaciones con
Matrices y Vectores
Matrices
Cuando resolvemos problemas de ingeniería, es importante saber visualizar los datos relacionados
con el problema. A veces consiste en un solo número, como el peso de un cuerpo, en otras ocasiones
podría ser una coordenada en un plano, la cual podemos representar como un par de números. En
todo caso, podemos representar cualquier ejemplo usando un ordenamiento de datos dispuestos en
filas y columnas llamado matriz.
Ejemplo:
Entonces tenemos 2 representaciones de datos para ingresar:

>> x = [4]
x=
4
>>mt = [23.7 6.7]

mt =
23.7 6.7
Ahora, para ingresar una matriz de cualquier orden debemos realizarlo fila por fila, donde un espacio
en blanco o una coma diferencian los datos de cada columna. Entonces:
>> A = [3 -6 8 0;2 1 7 -1;11 -7 2 -5]
A =
3 -6 8 0
2 1 7 -1
11 -7 2 -5
Matriz de Números Complejos

Si una matriz tiene al menos un elemento complejo, entonces dicha matriz es compleja.
Sea:
>> C = [7+i -2+5i;4 -9i]
C =
7.0000 + 1.0000i -2.0000 + 5.0000i
4.0000 0 - 9.0000i
25
Capítulo 2
También podemos obtener la matriz de los valores de la parte real y de la parte imaginaria de la matriz
C anteriormente definida.
>> Creal = real(C)
Creal =
7 -2
4 0
>> Cimaginario = imag(C)

Cimaginario =
1 5
0 -9
>> Carg = angle(C)

Carg =
0.1419 1.9513
0 -1.5708
>> Carg = angle(C)*180/pi

Carg =
8.1301 111.8014
0 -90.0000
Al igual que para un par de valores, podemos construir una matriz de complejos con la función
complex utilizando un par de matrices de igual orden. Tomando los resultados anteriores, tenemos:
>> Cnew = complex(Creal,Cimaginario)
Cnew =
7.0000 + 1.0000i -2.0000 + 5.0000i
4.0000 0 - 9.0000i
Matriz Nula
Se define la matriz nula, como aquella matriz que no tiene elementos, es decir, es la representación
del vacío. En Matlab se define así:
>> M = []
M=
[ ]
Nota
Se define como comentario a toda línea de texto que el programa no identifica como sintaxis de código,
su ingreso es después de anteponer el carácter % y que toma el color verde para su identificación.
26
Definición de Vector
Una matriz de orden nx1 o 1xm, se le conoce como vector fila o vector columna, respectivamente.
Ejemplo:
>> col = [2;-7;12;0]
col =
2
-7
12
0
>> fila = [14 -6 10 18 43]

fila =
14 -6 10 18 43
Operador paso (:)

Permite crear un vector fila de elementos en progresión aritmética.
Sintaxis: var = Vini : paso : V fin → paso ≠ 1
var =Vini : V fin → paso = 1
Ejemplos:
>> V = 9:3:21
V =
9 12 15 18 21
>> V1 = 6:10
V1 =
6 7 8 9 10
>> V2=45:-6:18
V2=
45 39 33 27 21
Reconocimiento de los Elementos de una Matriz
a P or sus índices
Sea A una matriz ingresada:
A =  aij  , donde : i = 1, 2,… , n y j = 1, 2, …, m
n× m
Entonces :
El elemento aij se reconoce por A(i, j )
27
Capítulo 2
Ejemplo:
>> A = [3 -6 8 0;2 1 7 -1;11 -7 2 -5];
>> a24 = A(2,4)
a24 =
-1
>> a12 = A(1,2)

a12 =
-6
b P or su posición en la matriz
Matlab asigna una numeración de posición a cada elemento de una matriz, donde:
A = [ ak ]n×m , donde k = 1, 2, … , n × m
Entonces :
El elemento ak se reconoce por A(k )
El programa inicia la asignación de la posición desde el primer elemento de la primera columna y

prosigue con los demás elementos con posiciones consecutivas, si ya asignó a todos los elementos
continúa en la columna que sigue con la posición siguiente. Vea el ejemplo a continuación, donde
los subíndices de cada elemento son sus respectivas posiciones en la matriz.
Sea:  31 −64 87 010 
A =  22 15 78 −111 
113 −7 6 29 −512 

>> A = [3 -6 8 0;2 1 7 -1;11 -7 2 -5];
A =
3 -6 8 0
2 1 7 -1
11 -7 2 -5
>>a6 = A(6)
a6 =
-7
>>a3 = A(3)
a3 =
11
28
Matrices Especiales
Existen en Matlab varias funciones orientadas a definir, con gran facilidad y muy rápidamente, algunas
matrices de tipo particular. La siguiente tabla especifica las funciones para crear estas matrices
especiales:
zeros Crea matriz de elementos igual a cero.
ones Crea matriz de elementos igual a la unidad.
eye Crea matriz identidad.
rand Crea matriz de elementos aleatorios entre 0 y 1.
randn Crea matriz de elementos aleatorios con media 0.
Las funciones anteriores tienen la siguiente sintaxis general para su generación:

Sintaxis: var = funcion(n)  matriz cuadrada
var= funcion(n,m)  “ rectangular
var = funcion([n m])  “ rectangular
La 1ra forma permite crear matrices cuadradas de orden “n”, la 2da y 3ra forma crea matrices
rectangulares de orden “nxm”.
Ejemplos:
Matrices de puros ceros:
>> Z1 = zeros(3)
Z1 =
0 0 0
0 0 0
0 0 0
>> Z2 = zeros(2,7)
Z2 =
0 0 0 0 0 0 0
0 0 0 0 0 0 0
>> Z3 = zeros([3 2])

Z3 =
0 0
0 0
0 0
29
Capítulo 2
Si queremos crear una matriz de ceros del mismo orden que la matriz A3x4 definida en los ejemplos
anteriores, utilizaremos la 3ra sintaxis definida.
>> Z4 = zeros(size(A))
Z4 =
0 0 0 0
0 0 0 0
0 0 0 0
Ya definida la matriz, podemos asignar a un dato un valor diferente a cero.

>> Z4(7) = 99
Z4 =
0 0 99 0
0 0 0 0
0 0 0 0
>> Z4(3) = 11
Z4 =
0 0 99 0
0 0 0 0
11 0 0 0
Matrices de elementos igual a la unidad:

>> U = ones(2)
U =
1 1
1 1
>> U1 = ones(2,9)
U1 =
1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1
>> U2 = 27*ones(4,6)
U2 =
27 27 27 27 27 27
27 27 27 27 27 27
27 27 27 27 27 27
27 27 27 27 27 27
30
Matriz Identidad:
>> I = eye(4)
I =
1 0 0 0
0 1 0 0
0 0 1 0
0 0 0 1
>> I1 = eye(3,6)
I1 =
1 0 0 0 0 0
0 1 0 0 0 0
0 0 1 0 0 0
Matriz de valores aleatorios entre 0 y 1:

>> x = rand % un valor aleatorio
x =
0.8147
>> x = rand % nuevamente un valor aleatorio

x =
0.9058
>> X = rand(5) % matriz de orden 5x5

X =
0.1270 0.5469 0.9572 0.9157 0.8491
0.9134 0.9575 0.4854 0.7922 0.9340
0.6324 0.9649 0.8003 0.9595 0.6787
0.0975 0.1576 0.1419 0.6557 0.7577
0.2785 0.9706 0.4218 0.0357 0.7431
>> X1 = rand(2,4)
X1 =
0.3922 0.1712 0.0318 0.0462
0.6555 0.7060 0.2769 0.0971
Si se desea cambiar el domino entre 0 y un valor, solo multiplicamos por dicho valor.
>> X2 = 25*rand(3)
X2 =
20.5864 23.7556 9.5390
17.3707 0.8612 19.1379
7.9275 10.9686 19.8800
31
Capítulo 2
Si deseamos tener datos entre dos valores consecutivos, sólo sumamos dicho valor.
>> X3 = 25+rand(3) % datos entre 25 y 26
X3 =
25.1869 25.6463 25.2760
25.4898 25.7094 25.6797
25.4456 25.7547 25.6551
>> X4 = 12+9*rand(1,5) % datos entre 12 y 21

X4 =
13.4635 13.0710 16.4853 20.6377 15.0635
Es lo mismo al trabajar con la función randn, sólo que en este caso algunos valores serán negativos.
Función Generador de Vectores
linspace: Crear un vector fila de una cierta cantidad de elementos distribuidos en un dominio
constante.
Sintaxis: var = linspace(Val_ini,Val_fin,# datos)
Los números de datos incluyen a Val_ini y Val_fin.
Ejemplo:
>> L = linspace(3,19,3)
L =
3 11 19
>> L = linspace(3,19,6)
L =
3.0000 6.2000 9.4000 12.6000 15.8000 19.0000
>> L = linspace(3,19); % crea un vector de 100 datos desde 3 a 19
logspace (a,b,n): Genera un vector logarítmicamente espaciado entre los valores 10^a y 10^b
con n elementos.
logspace (a,b): Genera un vector logarítmicamente espaciado entre los valores 10^a y 10^b
con 50 elementos.
Funciones Para el Análisis de Una Matriz
Existen diferentes funciones de aplicación directa a una matriz que realizan tareas específicas, las
cuales nos facilitan y agilizan, en muchos casos, soluciones de diversos problemas de cálculo. A
continuación mostramos algunas de estas funciones y su sintaxis de ejecución para su adecuado uso.
size: Al aplicarse a una matriz obtiene un vector de 2 elementos que indica el orden de dicha matriz.
El 1er elemento indica el número de fila y el 2do el número de columna.
Sintaxis: var = size(matriz)  var = [#f #c]
32
Ejemplo:
>> A = [3 -6 8 0;2 1 7 -1;11 -7 2 -5];
>> ordenA = size(A)
ordenA =
3 4
length: Obtiene la longitud máxima, en número de datos, de los lados de la matriz. Esto es similar
a obtener el max{# f , # c}
Sintaxis: var = length(matriz)  var = max{#f,#c}
Un caso particular es cuando aplicamos la función a un vector, donde el resultado es numéricamente

igual a su cantidad de elementos.
Ejemplo:
>> A = [3 -6 8 0;2 1 7 -1;11 -7 2 -5];
>> longitudA = length(A)
longitudA =
4
Aplicando a un vector:
>> fila = [14 -6 10 18 43];
>> Lf = length(fila)
Lf =
5
>> q = [19 5 10 -3];

>> Lq = length(q)
Lq =
4
sum: Esta función calcula la suma de los elementos de cada columna o fila y los resultados de dicho
cálculo los ordena en un vector.
Sintaxis: var = sum(matriz)
var = sum(matriz,1)
var = sum(matriz,2)
Las 2 primeras sintaxis realizan por defecto la suma de los elementos de cada columna, ordenando
cada resultado en un vector fila, y la última sintaxis suma los elementos de cada fila, ordenando cada
resultado en un vector columna. Y si aplicamos esta función a un vector, obtendremos como resultado
el valor de la suma de todos sus elementos.
33
Capítulo 2
Ejemplo:
>> A = [3 -6 8 0;2 1 7 -1;11 -7 2 -5];
>> As1 = sum(A,1)
As1 =
16 -12 17 -6
>> As2 = sum(A,2)

As2 =
5
9
1
>> fila = [14 -6 10 18 43]

>> sf = sum(fila)
sf =
79
prod: Esta función calcula el producto de los elementos de cada columna o fila y los resultados de
dicho cálculo los ordena en un vector.
Sintaxis: var = prod(matriz)
var = prod(matriz,1)
var = prod(matriz,2)
Análogamente a la función anterior, las 2 primeras sintaxis realizan por defecto el producto de los
elementos de cada columna, ordenando cada resultado en un vector fila y la última sintaxis realiza
el producto de los elementos de cada fila, ordenando cada resultado en un vector columna. Y si
aplicamos esta función a un vector, obtendremos como resultado el valor del producto de todos sus
elementos.
Ejemplo:
>> A = [3 -6 8 0;2 1 7 -1;11 -7 2 -5];
>> Ap1=prod(A,1)
Ap1 =
66 42 112 0
>> Ap2 = prod(A,2)

Ap2 =
0
-14
770
>> fila = [14 -6 10 18 43];

>> pf = prod(fila)
pf =
650160
34
max: Obtiene los máximos de cada columna de una matriz y los ordena en un vector fila, también
podemos conocer a qué fila pertenece el dato mayor de cada columna. Aplicando la función a un
vector nos muestra el mayor valor de todos los datos.
Sintaxis: mayor = max(matriz)
[mayor,#fila] = max(matriz)
Ejemplo:
>> A = [3 -6 8 0;2 1 7 -1;11 -7 2 -5]
A =
3 -6 8 0
2 1 7 -1
11 -7 2 -5
>> mayor = max(A)

mayor =
11 1 8 0
>> [mayor,filas] = max(A)

mayor =
11 1 8 0
filas =
3 2 1 1
>> vec = [14 -6 10 18 43];

>> Mv = max(vec)
Mv =
43
El valor mayor de una matriz se puede calcular así:

>> mayorT = max(max(A))
mayorT =
11
min: Obtiene los mínimos de cada columna de una matriz y los ordena en un vector fila, también
podemos conocer a qué fila pertenece el dato menor de cada columna. Aplicando la función a un
vector nos muestra el menor valor de todos los datos.
Sintaxis: menor = min(matriz)
[menor,#fila] = min(matriz)
35
Capítulo 2
Ejemplo:
Teniendo en cuenta la matriz A y el vector vec ingresados anteriormente.
>> menor = min(A)
menor =
2 -7 2 -5
>> [menor,filas] = min(A)

menor =
2 -7 2 -5
filas =
2 3 3 3
>> Mv = min(vec)
Mv =
-6
El valor menor de una matriz se puede calcular así:

>> menorT = min(min(A))
menorT =
-7
diag: Aplicado a una matriz extrae la diagonal principal ó k-ésima y lo ordena en un vector. Si es
aplicado a un vector nos creará una matriz diagonal con los elementos de dicho vector.
Sintaxis: var = diag(matriz)
var = diag(martiz,k) k=..-2,-1,1,2..
var = diag(vector)
var = diag(vector,k) k=..-2,-1,1,2..
Ejemplo:
Definiendo una matriz W y obteniendo sus diagonales k-ésimas.
>> W = [1 6 -2;0 9 3;-5 8 4]
W =
1 6 -2
0 9 3
-5 8 4
>> Do = diag(W) % diagonal principal de W

Do =
1
9
4
36
>> D1 = diag(W,1) % diagonal N° 1 de W

D1 =
6
3
>> D2m = diag(W,-2) % diagonal N° -2 de W

D2m =
-5
Creando matriz diagonal

>> v = [3 2 1];
>> Dv = diag(v)
Dv =
3 0 0
0 2 0
0 0 1
>> Dvk = diag(v,2)

Dvk =
0 0 3 0 0
0 0 0 2 0
0 0 0 0 1
0 0 0 0 0
0 0 0 0 0
>> Dvk = diag(v,-1)

Dvk =
0 0 0 0
3 0 0 0
0 2 0 0
0 0 1 0
Las siguientes funciones son utilizadas para aproximar valores numéricos de una matriz.
ceil Redondea el valor hacia el infinito.
fix Redondea el valor hacia cero.
floor Redondea el valor hacia el menos infinito.
round Redondea el valor hacia el entero próximo.
37
Capítulo 2
Aplicación:
>> P = [12.5624 4.2351 56.9870]
P =
12.5624 4.2351 56.9870
>> Pc = ceil(P)
Pc =
13 5 57
>> Pf1 = fix(P)

Pf1 =
12 4 56
>> Pf2 = floor(P)

Pf2 =
12 4 56
>> Pr = round(P)
Pr =
13 4 57
La siguiente tabla muestra más funciones de aplicación.

cond(A) Muestra el número de condición
det(A) Calcula la determinante
inv(A) Calcula la inversa
A' Calcula la transpuesta
poly(A) Obtiene el polinomio característico
eig(A) Calcula los valores propios
norm(A) Halla la norma
normmest(A,2) Estima la norma-2
null(A) Reconoce los espacios nulos
orth(A) Calcula la ortogonalización
pinv(A) Calcula la seudo inversa
trace(A) Calcula la traza
rank(A) Calcula el rango
rref(A) Obtiene la reducción mediante eliminación de Gauss
tril(A) Obtiene la matriz triangular inferior
triu(A) Obtiene la matriz triangular superior
dot(v1,v2) Calcula el producto escalar de los vectores
cross(v1,v2) Calcula el producto vectorial de los vectores v1 y v2,
donde ambos deben ser de orden 1x3 ó 3x1.
(Con A matriz, v1 y v2 vectores).
38
Aplicación:
>> A = [3 -6 8 0;2 1 7 -1;11 -7 2 -5;2 -1 6 1]
>> dA = det(A) % determinante
dA =
-786.0000
>> iA = inv(A) % inversa

iA =
-0.1985 -0.1221 0.0992 0.3740
-0.1845 0.0916 0.0089 0.1361
0.0611 0.1145 -0.0305 -0.0382
-0.1539 -0.3511 -0.0064 0.6170
>> At = A’ % transpuesta
At =
3 2 11 2
-6 1 -7 -1
8 7 2 6
0 -1 -5 1
>> Ap = poly(A) % polinomio característico

Ap =
1.0000 -7.0000 19.0000 377.0000 -786.0000
>> Avp = eig(A) % valores propios

Avp =
-5.6726
5.3413 + 6.4108i
5.3413 - 6.4108i
1.9900
>> Atz = trace(A) % traza

Atz =
7
>> Ar = rank(A) % rango

Ar =
4
>> Ag = rref(A) % eliminacion por Gauss

Ag =
1 0 0 0
0 1 0 0
0 0 1 0
0 0 0 1

39
Capítulo 2
>> Atl = tril(A) % triangular inferior

Atl =
3 0 0 0
2 1 0 0
11 -7 2 0
2 -1 6 1
>> Atu = triu(A) % triangular superior

Atu =
3 -6 8 0
0 1 7 -1
0 0 2 -5
0 0 0 1
>> v1=[1 2 3];v2=[4 5 6];

>> Pp=dot(v1,v2)
Pp =
32
>> Pc=cross(v1,v2)
Pc =
-3 6 -3
Funciones Adicionales
find(A) Devuelve los índices donde las entradas de A son distinto de cero
fliplr(A) Intercambia la matriz de izquierda a derecha
flipud(A) Intercambia la matriz de arriba abajo
reshape(A,n,m) Devuelve una matriz m x n cuyos elementos se toman por
columnas de A, si A no contiene m x n elementos daría un error
rot90(A) Gira la matriz 90º en sentido contrario a las agujas del reloj
rot90(A,n) Gira la matriz nx90º
expm(A) Matriz exponencial de A
sqrtm(A) Matriz raíz cuadrada
logm(A) Matriz logarítmica
funm(A,@funcion) Evalúa la función que indiquemos en la matriz A
[Vep,Vap]=eig(A) Vep son los vectores propios y Vap son los valores propios de A
[L,U]=lu(A) Factorización LU
[Q,R]=qr(A) Factorización QR
[U,S,V]=svd(A) Calcula la descomposición en valores singulares de A. Donde U y
V son matrices unitarias
(Con A matriz, m y n naturales).
40
Ejemplos:
>> A = [pi 0; pi/4 pi/3]
A =
3.1416 0
0.7854 1.0472
>>Af = find(A) % devuelve los índices como un vector columna

Af =
1
2
4
>> Arsh = reshape(A,1,4)

Arsh =
3.14160.7854 0 1.0472
>>A90 = rot90(A) % gira la matriz 90º

A90 =
0 1.0472
3.1416 0.7854
>>A270 = rot90(A,3) % gira la matriz 270º ( 90º x 3 = 270º )

A270 =
0.7854 3.1416
1.0472 0
>> funm(A,@sin) % calcula el seno de cada elemento de la matriz

ans =
0.0000 0
-0.3248 0.8660
>> Ae = expm(A)
ans =
23.1407 0
7.6091 2.8497
41
Capítulo 2
Operadores y Funciones Matemáticas
En la realización de operaciones con las matrices, debemos tener en cuenta si dicha operación
es matricial o de elemento a elemento (operación de arreglos), pues ambos son muy diferentes y
pueden realizarse por operadores o funciones, entonces es necesario conocer cómo se aplica las
funciones y además cómo se realizan las operaciones.
Operadores Aritméticos
Tabla de Operadores Aritméticos I
Operador Descripción
A + B Adición de matrices
A - B Sustracción de matrices
A * B Producto de matrices
A / B División de matrices = A*B-1
A ^ n Potencia de matriz
(Siendo A y B matrices del mismo orden, n escalar).
>> A=[1 3;3 4];
>> B=[2 1;4 3],
B =
2 1
4 3
>> A+B
ans =
3 4
7 7
>> A-B
ans =
-1 2
-1 1
>>A*B
ans =
14 10
22 15
>> A/B
ans =
-4.5000 2.5000
-3.5000 2.5000
>> A^3
ans =
55 90
90 145
42
Si anteponemos un punto a los operadores *,/ y ^, la operación se realizará elemento a elemento.

Ver tabla siguiente:
Tabla de Operadores Aritméticos II
A .* B Producto elemento a elemento: aij*bij
A ./ B División elemento a elemento: aij/bij
A .^ B Potencia elemento a elemento: aij^bij
A .^ n Potencia elemento a elemento: aij^n
(Siendo A y B matrices del mismo orden, n escalar).
>> A.*B
ans =
2 3
12 12
>> A./B
ans =
0.5000 3.0000
0.7500 1.3333
>> A.^B
ans =
1 3
81 64
>> A.^4
ans =
1 81
81 256
Operadores relacionales
Matlab como lenguaje de programación dispone de operadores relacionales que permite hacer
comparaciones entre los elementos de dos arreglos de igual dimensión; en cualquiera de los casos
siguientes, el resultado es un arreglo de 0 (ceros) o 1 (unos) cuando la relación es falsa o verdadera,
respectivamente. Estos operadores son los siguientes:
Tabla de Operadores Relacionales
> Mayor que
< Menor que
== Igual que
<= Menor que
>= Mayor que
~= Diferente que
43
Capítulo 2
Operadores lógicos
Permite hacer comparaciones entre los elementos de dos arreglos de igual dimensión; en cualquiera
de los casos siguientes, el resultado es un arreglo de 0 (ceros) o 1 (unos) como en el ítem anterior.
Estos operadores son los siguientes:
Tabla de Operadores Lógicos
& y (and)
| o (or)
~ no (not)
= identico
Ejemplos:
Teniendo en cuenta a las matrices A y B definidas anteriormente, tendremos:
>> C=A>B
C =
0 1
0 1
>> C=(A==B)
C =
0 0
0 0
Funciones Relacionales y Lógicas Adicionales
Tabla de Funciones
xor(x,y) Operación “o” exclusiva, devuelve 0 si ambas son falsas o ambas verdaderas
y devuelve 1 si una es falsa y la otra verdadera.
any(x) Devuelve 1 si algún elemento en un vector x es no nulo y devuelve 0 si son
todos nulos, si se trata de una matriz da una respuesta por cada columna
all(x) Devuelve 1 si todos los elementos en un vector x son no nulos y 0 si existe
alguno nulo y si se trata de una matriz da una respuesta por cada columna
exist('x') Devuelve uno si existe y cero si no existe
isnan(x) Devuelve unos en magnitudes no numéricas (NaN) en x
isinf(x) Devuelve unos en magnitudes infinitas (Inf) en x
isfinite(x) Devuelve unos en valores finitos en x
Podemos ver muchos más casos pero todos serían similares: ischar, isempty, isequal,
Nota
isfloat, isinteger, islogical, isnumeric, isprime, isreal, isscalar, isspace…
44
Ejemplo:
>> c = [Inf 0 5 -8 NaN 94];
>> exist (‘c’) % pregunta si existe alguna variable llamada c
ans =
1
>> isnan (c) %c es NaN? devuelve 1 si es verdadero y 0 si es falso

ans =
0 0 0 0 1 0
>> isinf (c) %c es Inf? devuelve 1 si es verdadero y 0 si es falso

ans =
1 0 0 0 0 0
Funciones Matemáticas
Para la simplicidad de cálculo, Matlab tiene una variedad de funciones que afectan solamente a todos
los elementos de cada matriz a la que es aplicada, mas no altera el orden de estas. De ahí que al
aplicarse a vectores podemos deducir la forma de operar entre vectores que es al de elemento a
elemento. La siguiente tabla nos indica las funciones matemáticas más conocidas:
Tabla de Funciones Algebraicas
abs(A) Valor absoluto de A
sqrt(A) Raíz cuadrada de A
sign(A) Función signo de A
exp(A) Exponencial de A
log(A) Logaritmo natural de A
log10(A) Logaritmo en base 10 de A
log2(A) Logaritmo en base 2 de A
power(A,n) Potencia n-ésima de A
mean(A) Calcula la mediana de las columnas de la matriz A ó la
mediana de un vector A
diff(A) Calcula la diferencias divididas de primer orden a las
columnas de la matriz A y lo mismo para un vector A
cumprod(A) Devuelve el producto acumulativo de las columnas de la
matriz A y lo mismo para un vector A.
Observación: La función mean al aplicarse a una matriz sólo devuelve un vector fila de una cantidad
de elementos igual al de dicha matriz y un elemento si es que se aplica a un vector. La función diff
al aplicarse a una matriz devuelve otra matriz de igual cantidad de columnas, pero de número de filas
menor en una unidad de la matriz aplicada.
45
Capítulo 2
Ejemplos:
>> A=[-2 4;1 -6];
>> abs(A)
ans =
2 4
1 6
>> exp(A)
ans =
0.1353 54.5982
2.7183 0.0025
>> power(A,3)
ans =
-8 64
1 -216
>> mean(A)
ans =
-0.5000 -1.0000
>> diff(A)
ans =
3 -10
Tabla de Funciones Trigonométricas

sin(A) Seno de A
cos(A) Coseno de A
tan(A) Tangente de A
cot(A) Cotangente de A
csc(A) Cosecante de A
sec(A) Secante de A
asin(A) Arco Seno de A
acos(A) Arco Coseno de A
atan(A) Arco Tangente de A
sinh(A) Seno hiperbólico de A
cosh(A) Coseno hiperbólico de A
tanh(A) Tangente hiperbólico de A
asinh(A) Arco Seno hiperbólico de A
acosh(A) Arco Coseno hiperbólico de A
atanh(A) Arco Tangente hiperbólico de A
Observación: Para las funciones inversas asin y acos tener en cuenta que los datos deben estar
definidos entre el dominio [-1 , 1].
46
De la matriz A, anterior definida:

>> sin(A)
ans =
-0.9093 -0.7568
0.8415 0.2794
>> sinh(A)
ans =
-3.6269 27.2899
1.1752 -201.7132
>> csc(A)
ans =
-1.0998 -1.3213
1.1884 3.5789
Funciones de fecha y hora
Tabla Principal
date Devuelve la fecha actual del sistema
calendar Muestra el calendario del mes actual
calendar(año,mes) Calendario del mes y año específico
Eomday(año,mes) Último día de mes y año específico
Ejemplo:
>> date
ans =
14-Feb-2012
>> calendar
Feb 2012
S M Tu W Th F S
0 0 0 1 2 3 4
5 6 7 8 9 10 11
12 13 14 15 16 17 18
19 20 21 22 23 24 25
26 27 28 29 0 0 0
47
Capítulo 2
Operaciones con Funciones
Debemos tener en cuenta la forma de ejecución y sobretodo del tipo de resultado que deseamos
obtener cuando realicemos las operaciones utilizando las funciones matemáticas de Matlab. A
continuación, mostramos una forma práctica de realizar los cálculos:
Sea:
>> x=[0:2] % vector de 1x3
x =
0 1 2
>> y1=exp(x) % al afectar a x la dimensión no cambia

y1 =
1.0000 2.7183 7.3891
Donde:
y1 = [y1(1) y1(2) y1(3)]
>> y2=sin(x) % igualmente la dimensión de x no cambia

y2 =
0 0.8415 0.9093
Donde:
y2 = [y2(1) y2(2) y2(3)]
Pero si necesitamos calcular una expresión algebraica que depende de dos o más funciones
matemáticas, debemos recordar que cada función es una matriz o vector de igual dimensión que el
argumento a la cual se aplica, por lo tanto se tendría que realizar la operación elemento a elemento.
Entonces, si queremos representar la siguiente expresión en el Matlab:
para , el resultado debería ser:
Para lo cual realizamos en el programa lo siguiente:
>>y=exp(x).*sin(x) %
y =
0 2.2874 6.7188
Donde:
y = [y1(1)*y2(1) y1(2)*y2(2) y1(3)*y2(3)]
Análogamente la división será de la forma siguiente:

>>Y=exp(x)./sin(x) %
y =
0 2.2874 6.7188
Donde:
Y = [y1(1)/y2(1) y1(2)/y2(2) y1(3)/y2(3)]
48
Ejercicio de aplicación
Sea el sistema de ecuaciones lineales:
Resuelva dicho sistema y calcule el valor de E, siendo:
Solución:
Resolvemos el sistema de ecuaciones lineales representándola en la forma matricial:
AX=b, donde A es la matriz de coeficientes, X es el vector de las variables y, b el vector de los
resultados. Entonces, tendremos lo siguiente:
Sabiendo que X=A-1b, donde , realizamos los cálculos en Matlab:
>> A=[-3 6 -2 4;4 -2 3 -5;7 8 -4 -2;5 -9 -7 8]; %ingresando matriz

>> b=[19;-11;3;-2]; % ingresando vector resultado
>> X=inv(A)*b % obteniendo el vector solución
X =
1.0000
2.0000
3.0000
4.0000
Entonces podemos observar que:
49
Capítulo 2
Pero aplicando la sintaxis de Matlab podemos resolver la expresión de E de la siguiente manera:

Por lo tanto, realizaremos la siguiente sintaxis:

>> E=(sum(X.^2)^2+prod(X))/sum(X.^X)
E =
3.2083
Ejercicios: Con sintaxis de Matlab realice lo siguiente:

a) Halle el valor del factorial de un número natural cualquiera.
b) La suma de los primeros 100 números naturales.
c) La suma de los primeros 250 números pares.
d) La suma de los primeros 250 cuadrados perfectos.
e) La suma de los primeros 250 cubos perfectos.
Solución:
a) f=prod(1:n) % n debe ser un número mayor o igual a 1
b) s1=sum(1:100)
c) s2=sum(2:2:500)
Sea
>> x=1:250; % vector de los primeros 250 número naturales
d) s3=sum(x.^2) % suma de los 250 primeros cuadrados perfectos
e) s4=sum(x.^3) % suma de los 250 primeros cubos perfectos
50
Indexación de Matrices
Consiste en obtener una submatriz de otra que ya fue definida.

Sea: donde:
Si deseamos obtener una submatriz a partir de A, entonces haremos lo siguiente:
Ejemplo:
>> P=round(50*rand(6,8)) % creando una matriz aleatoria
P =
41 14 48 40 34 35 35 38
45 27 24 48 38 2 16 40
6 48 40 33 37 14 48 9
46 48 7 2 20 2 2 24
32 8 21 42 33 5 22 22
5 49 46 47 9 41 19 32
>> subP1=P([3 5 6],[2 3 5 7 8])

subP1 =
48 40 37 48 9
8 21 33 22 22
49 46 9 19 32
Un caso particular es cuando deseamos extraer una fila o una columna, pues normalmente tendríamos
que hacer lo siguiente:
>>Pf5=P(5,[1:8]) % Obtención de la 5ta fila
Pf5 =
32 8 21 42 33 5 22 22
51
Capítulo 2
En este caso involucra un vector que especifica a todas las cantidades de columnas, si eso ocurre,
podemos abreviar la sintaxis, que realizará acción semejante, de la siguiente manera:
>> Pv5=P(5,:) % obtención de la 5ta fila
Pv5 =
32 8 21 42 33 5 22 22
>>Pc3=P(:,3) % obtención de la 3ra columna de P
Pc3 =
48
24
40
7
21
46
Conocido esto, nos resultará fácil eliminar una(s) fila(s) o columna(s) si es que asignamos a estas
el valor del vacío.
>> P
P =
41 14 48 40 34 35 35 38
45 27 24 48 38 2 16 40
6 48 40 33 37 14 48 9
46 48 7 2 20 2 2 24
32 8 21 42 33 5 22 22
5 49 46 47 9 41 19 32
>> P(:,[1 3])=[]

P =
14 40 34 35 35 38
27 48 38 2 16 40
48 33 37 14 48 9
48 2 20 2 2 24
8 42 33 5 22 22
49 47 9 41 19 32
>> P([2 5],:)=[]

P =
14 40 34 35 35 38
48 33 37 14 48 9
48 2 20 2 2 24
49 47 9 41 19 32
Observación: Sólo es posible eliminar filas o columnas de forma completa.
52
Concatenación de matrices (Agrupación)
Consiste en agrupar 2 o más matrices para formar una de ordenmayor. Se mantiene las características
de cada matriz, porque son las variables que representan a estas con las que se realiza la
concatenación. Por su forma de agrupación se definen dos tipos:
• Concatenación Horizontal: Para agrupar de esta forma a un conjunto de matrices se debe tener
en cuenta que el número de filas de estas deben ser iguales y se agruparán como elementos de
un vector fila.
• Concatenación Vertical: En este caso la agrupación se realizará con matrices que tienen igual
número de columnas y se agruparán como elementos de un vector columna.
Ejemplo:
% Generando las matrices R3x5, T2x5 y W3x1
>>R=round(32*rand(3,5))
R =
18 24 18 17 4
29 24 2 25 18
9 12 2 30 15
>>T=round(16*rand(2,5))
T =
0 3 5 3 4
5 13 8 10 10
>> W=round(56*rand(3,1))
W =
39
42
25
Se observa que R y W tienen igual cantidad de filas,además R y T tienen la misma cantidad de

columnas. Entonces:
>>I1=[R W] % Concatenación horizontal entre R y W
I1 =
18 24 18 17 4 39
29 24 2 25 18 42
9 12 2 30 15 25
>>I2=[R;T] % Concatenación vertical entre R y T

I2 =
18 24 18 17 4
29 24 2 25 18
9 12 2 30 15
0 3 5 3 4
5 13 8 10 10
53
Capítulo 2
Ejercicios propuestos
1. Sea la matriz cuadrada:
a) Construya una matriz añadiendo la matriz identidad de rango 3 a la derecha de la matriz A.

b) Sume a la tercera fila, la primera fila multiplicada por -3.
c) Cambie la primera columna de A por la tercera.
d) Construya una nueva matriz cuyas columnas sean las columnas 1ra y 3ra de A.
e) Construya una nueva matriz cuyas filas sean las columnas 1ra y 3ra de A.
2. Sea la matriz cuadrada:
a) Halle el valor mínimo dentro de cada fila de A.

b) Ordene los elementos de A en orden descendente dentro de cada columna.
c) Ordene los elementos de A en orden ascendente dentro de cada fila.
d) Forme una lista con los elementos de A ordenada de forma ascendente.
e) Halle el máximo en valor absoluto de los elementos de la matriz A.
3. Con una sola orden de MATLAB cree una matriz aleatoria 4x4 de números reales entre -5 y 5.
Indicación: Ejecute help rand para saber cómo generar números aleatorios en distribuciones
uniformes (randn se emplea para distribuciones normales).
4. En una sola orden de MATLAB cree una matriz 3x5 cuyo único elemento sea el 7.
5. Con una sola orden de MATLAB cree una matriz aleatoria 4x4 de números enteros entre -5 y 5.
6. Considere la siguiente orden de MATLAB: A=magic(5). En una sola orden:
a) Defina una matriz B formado por las filas pares de la matriz A.
b) Defina una matriz C formado por las columnas impares de la matriz A.
c) Defina una vector d formado por la tercera columna de la matriz A
d) Elimine la tercera fila de la matriz A.
7. Sea x=0:pi/2:2*pi, con una sola orden de MATLAB cree una matriz cuya primera fila es x, su
segunda fila es el seno de cada elemento de x y cuya tercera fila es el coseno de cada elemento
de x.
54
8. Defina un vector aformado por los cuatro primeros números impares y otro bformado por los
cuatro primeros números pares de varias formas distintas. Empléelos para construir la matriz:
9. Construya una matriz

Con
Con
Ejercicios más avanzados
1. En una sola instrucción, cambie todos los valores de la diagonal de una matriz cuadrada a cero.
2. En una sola instrucción, sustituya todos los valores de la diagonal de una matriz cuadrada por los
elementos de un vector dado.
3. Ordene los elementos de una matriz del menor a mayor manteniendo su forma (indicación:
emplee la orden reshape).
4. En una sola instrucción, ponga a cero todos los elementos negativos de una matriz.
5. En una sola instrucción, ponga a cero todos los elementos de una matriz que estén entre -1 y 1.
(La conjunción lógica es &).
6. De tres formas distintas (cada una en una sola instrucción), averigue el número de elementos de
una matriz, de forma que al final tengamos un número.
55
3
Capítulo
Programación
en Matlab
Un lenguaje de programación es un lenguaje que puede ser utilizado para controlar el comportamiento
de una máquina, particularmente una computadora. Consiste en un conjunto de símbolos y reglas
sintácticas y semánticas que definen su estructura y el significado de sus elementos y expresiones,
permite especificar de manera precisa sobre qué datos de una computadora debe operar, cómo
deben ser estos almacenados, transmitidos y qué acciones debe tomar bajo una variada gama
de circunstancias. Todo esto, a través de un lenguaje relativamente próximo al lenguaje humano
(lenguaje de alto nivel).
Todo programa en su edición debe tener en cuenta las 3 lógicas de programación, que se definen
como: Lógica Secuencial, Lógica Selectiva y Lógica Repetitiva.
En este capítulo conoceremos cómo editar e implementar un programa utilizando la sintaxis del
Matlab, manteniendo los criterios de las lógicas en la cual se gobiernan, y que dependiendo de su
estructura podrá ser reconocido como M-File.
M-FILES
La programación en Matlab se realiza básicamente sobre archivos M o M-files. Se los denomina de
esta forma debido a su extensión ".m". Pueden ser creados y editados desde cualquier editor de texto
común; por ejemplo, el Bloc de Notas. Pero el Matlab incluye un lugar propio llamado editor debuggerel
cual se invoca con la instrucción edit. Si se opta por un editor externo se debe tener en cuenta que
los archivos deban ser guardados con esta extensión.
De acuerdo a su edición, estos archivos pueden separarse en dos tipos:
• Script o Archivo de Comandos
• Funciones
Script: Son archivos que contiene líneas de instrucciones del Matlab, manteniendo mínimamente una
lógica secuencial en su edición. Este archivo ya editado se guarda con un nombre específico dando a
lugar que dichas instrucciones sean desde ese instante representadas por tal nombre, entonces, si
queremos ejecutar las instrucciones bastará con escribir dicho nombre en la ventana de comandos.
Aquí se debe notar algo importante: Todas las variables que se hayan definido o creado dentro de este
archivo, luego de su ejecución pasarán a formar parte del workspace. Se debe tratar de que la variable
del workspace no coincida con las que aparecen en el script que se ha de ejecutar.
57
Capítulo 3
Ejemplo:
Implementar un script que calcule el valor de la hipotenusa de un triángulo rectángulo cuyos catetos
tienen los valores de 12 y 17.
Solución:
Invocamos al editor debugger.
>> edit
Iniciando la edición del script:
El archivo fue guardado con el nombre de hipotenusa, note en la parte superior de la ventana el
nombre con el que fue guardado.
Ejecutando el script en la ventana de comandos:
>> hipotenusa
Your variables are:
a b c
Según la línea 8 del script hipotenusa la salida de la ejecución que debe dar la instrucción who son
las variables creadas en el workspace.
58
Función: En principio existen dos tipos de funciones: las funciones inline, que se insertan enla línea
de comandos y las que se escriben en un documento de texto externo (M-File). Esta últimaforma,
que es la evolución natural de los ficheros script, es más flexible y es en la que noscentraremos a
continuación. La función es un M-file con cabecera de ejecución definida, es decir tiene por primera
línea una sintaxis definida por:
function [argumentos_salidas]=nombre(argumentos_entradas)
Donde:
nombre: Corresponde al nombre de la función.
argumentos_salidas:Representa a un vector de elementos o variables de retorno de la
función. El valor de cada uno de los elementos varía a medida que se ejecuta el algoritmo. Los
valores devueltos por la función convocada serán los valores que se encuentran en argumentos_
salidas en el momento en que termina la ejecución de la función. La definición de esta salida es
opcional; de no aparecer la función se convertirá en un procedimiento, puesto que no devuelve
nada; sólo acepta parámetros y ejecuta el algoritmo dado.
argumentos_entradas:Son los parámetros que recibe la función para realizar su
procesamiento. Estos argumentos, durante la ejecución, son parámetros recibidos por valor (by
value); es decir, se hacen duplicados de los parámetros y en estos sobre los cuales se realizan
todas las modificaciones.
Contrario a los scripts, todas las variables que se definan dentro del cuerpo o definición de la función,
si la función es invocada desde la ventana de comandos, no pasarán a formar parte de nuestro
workspace.
Es muy importante que guardemos el archivo con el mismo nombre de la función definida en la cabecera.
Nota
De no hacer esto será un error
La función solamente se aplica y es de la siguiente manera:

>>[variables_de_salida]=nombre(argumentos_entradas)
Ejemplo:
Vamos a crear una función que obtenga el conjunto solución para un sistema de n ecuaciones
lineales compatible determinado, haciendo uso de una matriz A de coeficientes, y un vector dado B
de términos independientes, es decir, obtendremos un X tal que AX=B. Dicho vector X será devuelto
por la función.
Solución:
Observamos que las matrices A y B son los argumentos de entrada, y particularmente están definidas
así:
, las cuales ingresamos de esta manera:
>> A=[1 0 2;5 4 1;-2 1 -1];

>> B=[12;4;-8];
59
Capítulo 3
Entonces, editamos nuestro código para la función:
Note que el archivo fue guardado con el mismo nombre solución que de la función.
Aplicamos la función de la siguiente manera:
>> Xo=solucion(A,B)
Xo =
0.5714
-1.1429
5.7143
inline: Permite crear en línea una función que representará a una expresión algebraica.
Sintaxis:
var = inline('Expresión matemática en forma de cadena')
Ejercicio:
Usando un archivo de función en MATLAB para la siguiente función:
La entrada de la función será x, y la salida será y. Escriba la función de forma que xpueda ser un
vector, y utilícela para calcular el valor de la expresión evaluada en x e [-2,2] siendo x entero.
Solución:
Usando funciones en línea, escribiremos en el editor lo siguiente:
1 x=[-2:2]; % extension de x como vector
2 f=inline('0.9*x.^4-12*x.^2-5*x'); % funcion f(x)
3 y=g(x) % evaluando la funcion f en los valores de x
60
Guardando el archivo con el nombre sol_inline y ejecutando, tendremos:

>> sol_inline
y =
-23.6000 -6.1000 0 -16.1000 -43.6000
Funciones de Ingreso y Salida de datos

Normalmente al realizar un M-File nos vemos en la necesidad de interactuar con el usuario del
programa, ya sea para solicitar ingreso de datos o mostrando resultados en pantalla. Estas acciones
están definidas en Matlab como funciones in/out de datos. A continuación especificamos algunos de
estos que son muy utilizados en la edición de un código:
input: Permite al usuario ingresar un conjunto de datos desde el teclado previa exhibición de una
cadena de texto como mensaje de solicitud, dicho ingreso de dato es asignado a una variable.
Sintaxis: var = input('cadena de mensaje');
var = input('cadena de mensaje','s');
La primera sintaxis permitirá el ingreso de datos como si estuviéramos en la ventana de comandos

y la segunda forma especifica que todo lo ingresado será una cadena de texto, es decir los datos
ingresados serán ya de tipo char.
Ejemplo:
>> w=input('Ingresar un vector fila de 3 elementos: ');
Ingresar un vector fila de 3 elementos: [6 9 1]
>> w % invocando a la variable w
w =
6 9 1
En este caso se tuvo que ingresar el vector fila [6 9 1] para que termine la ejecución realizada. La
variable w tomó el valor del vector ingresado.
Se muestra a continuación cómo ingresar una cadena de texto desde el teclado:
>> n=input('Nombre: ','s');
Nombre: Rosario Taipe
>> n
n =
Rosario Taipe
disp: Muestra en pantalla lo representado por una variable.

Sintaxis:
var = disp(variable);
61
Capítulo 3
Ejemplo:
>> n=input('Nombre: ','s');
Nombre: Rosario Taipe
>> disp(n) % muestra lo representado por la variable n

Rosario Taipe
También es aceptado mostrar de forma directa una cadena de texto:

>> disp('Hola Mundo') % muestra la cadena de texto
Hola Mundo
fprintf: Se utiliza para visualizar salidas de programas (texto y datos) en la pantalla, o bien
almacenarlas en un fichero. Con este comando, y a diferencia de disp, la salida puede tener un
formato preestablecido. En este caso se puedencombinar texto y resultados numéricos provenientes
de cálculos o variablespredefinidas en la misma línea. Además, el formato de los números se
puedecontrolar directamente.
Uso del comando fprintf para visualizar mensajes de texto:
>>fprintf('Mensaje en forma de cadena\n')
Nota Para cambiar de línea en un mensaje de texto se debe insertar el código \n.
A este código se le denomina Código de escape.

Utilización del comando fprintf para visualizar datos y texto juntos:
Para visualizar texto y datos (valores de variables) juntos, el comando fprintf debeutilizarse
siguiendo la sintaxis:
>>fprintf('Texto %-5.2f texto adicional', nombre_variable)
El símbolo % marca Elementos de formato Nombre de la variable

del lugar donde se (definen el formato del cuyo valor será
insertará el número número) visualizado
dentro del texto
62
Los elementos del formato son:

-5.2f
Flag o bandera Ancho del campo y Caracter de conversión

(opcional) precisión (opcional) (obligatorio)
El flag o bandera, cuyo carácter es opcional, puede ser uno de los siguientes:
Caracter Descripción
+ (signo mas) Justificación izquierda del número dentro del campo
- (signo menos) Visualiza el carácter de signo ( + o -) delante del número
0 (cero) Añade ceros si el número es más pequeño que el campo
La especificación del ancho y precisión del campo (5.2 en el ejemplo anterior) es opcional. El primer
número (5 en nuestro ejemplo) es el ancho del campo, el cual nos indica el menor número de dígitos
en la visualización. Si el número que se visualiza esmenor que el ancho del campo, se añadirán ceros
o espacios delante del número encuestión. La precisión se corresponde con el segundo número en el
ejemplo anterior, y especifica el número de dígitos que se mostrarán a la derecha del punto decimal.
El último elemento es el correspondiente al formato de conversión (f en el ejemplo anterior). Éste es
obligatorio.
A continuación se muestran los caracteres de conversiónmás utilizados:
e Notación exponencial en minúsculas (ej. 1.709098e+001).
E Notación exponencial en mayúsculas (ej. 1.709098E+001).
f Notación de punto fijo (ej. 17.090980).
g Representación en formato corto de las notaciones e o f.
G Representación en formato corto de las notaciones E o f.
i Entero.
Se puede obtener información adicional sobre estos y otros formatos utilizando la ayudade MATLAB,
el menú Help (Ayuda).
Ejemplo:
Pedir al usuario por pantalla tres números y responde con el mensaje: Promedio de los números
ingresados es...
Solución:
Realizando un script, en el editor escribiremos las siguientes líneas:
63
Capítulo 3
1 n1=input('Ingrese el primer numero: ');

2 n2=input('Ingrese el segundo numero: ');
3 n3=input('Ingrese el tercer numero: ');
4 prom=(n1+n2+n3)/3;
5 fprintf('Promedio de los numeros ingresado es:%f\n',prom);
Guardando este script con nombre solprom1 y ejecutando tendremos:

Ingrese el primer numero: 24
Ingrese el segundo numero: 11
Ingrese el tercer numero: 26
Promedio de los numeros ingresado es: 20.333333
Sentencias de Control de Flujo

Hoy en día las aplicaciones informáticas son mucho más ambiciosas que las necesidades de
programación existentes antaño, principalmente debido a las aplicaciones gráficas, por lo que las
técnicas de programación estructurada no son suficientes. Ello ha llevado al desarrollo de nuevas
técnicas, tales como la programación orientada a objetos y el desarrollo de entornos de programación
que facilitan la programación de grandes aplicaciones.La programación estructurada es una técnica
para escribir programas (programación de computadora) de manera clara, teniendo en cuenta el
Teorema del Programa Estructurado, propuesto por Böhm-Jacopini, el cual demuestra que todo
programa puede escribirse en base únicamente a tres estructuras de control:
• Secuencial
• Selectica (Instrucción condicional)
• Repetitiva (Iteración, bucle de instrucciones, con condición al principio)
Solamente con estas tres estructuras se pueden escribir todos los programas y aplicaciones posibles.
Si bien los lenguajes de programación tienen un mayor repertorio de estructuras de control, éstas
pueden ser construidas mediante las tres básicas citadas.
Estructura secuencial: Una estructura de programa es secuencial si las instrucciones se ejecutan una
tras otra, a modo de secuencia lineal, es decir que una instrucción no se ejecuta hasta que finaliza
la anterior, ni se bifurca el flujo del programa.
Ejemplo:
1 x = 12;
2 y = 15;
3 z = x+y;
Sólo es posible realizar el cálculo de z si previamente se ha definido x y y.

Estructura selectiva o de selección: La estructura selectiva permite que la ejecución del programa
se bifurque a una instrucción (o conjunto) u otras, según un criterio o condición lógica establecida,
sólo uno de los caminos en la bifurcación será el tomado para ejecutarse. Para ello contamos con las
instrucciones de control if…else…end y switch…case…end.
64
if … else … end
Diagrama de Flujo: Sintaxis:
if condición
<Sentencias1>;
else
<Sentencias2>;
end
condición: Es una expresión lógica o relacional cuyo resultado es de tipo lógico, valor de 1 (uno) si
el resultado es verdadero ó 0 (cero) si el resultado es falso.
Sentencias1: Es un conjunto de sentencias a ejecutarse siempre que la respuesta de condición sea
verdadera.
Sentencias2: Es un conjunto de sentencias a ejecutarse siempre que la respuesta de condición sea
falsa.
Casos Especiales:
• Ausencia de cláusula else
if condición
<Sentencias>;
end
65
Capítulo 3
• Respuesta solamente ante la cláusula else

if condición
; % sentencia nula
else
<Sentencias>;
end
if … elseif … else … end (Anidado)
if condición
<Sentencias1>;
elseif
<Sentencias2>;
elseif
<Sentencias3>;
.
.
.
elseif
<SentenciasN>;
else
<Sentencias por Defecto>;
end
66
Ejemplo ilustrativo:
Implementar un archivo script que solicite el ingreso de dos números cualesquiera y muestre en
pantalla el mayor de ambos.
Solución: Abrimos el editor y escribimos lo siguiente:
a=input('Ingrese valor de a= ');
b=input('Ingrese valor de b= ');
if a>b
fprintf('\nEl mayor es a=%i\n',a);
else
fprintf('\nEl mayor es b=%i\n',b);
end
Guardamos el script con el nombre mayor2n, ejecutamos y probamos:

>> mayor2n % ejecutando
Ingrese valor de a= 14
Ingrese valor de b= 18
El mayor es b=18
Pero si los valores ingresados por el usuario son iguales nos damos cuenta que el resultado debe ser
diferente, por lo tanto debemos modificar el script para considerar la condición de igualdad, entonces
tendremos lo siguiente:
a=input('Ingrese valor de a= ');
b=input('Ingrese valor de b= ');
if a>b
fprintf('\nEl mayor es a=%i\n',a);
elseif b>a
fprintf('\nEl mayor es b=%i\n',b);
else
fprintf('\na=%i y b=%i son iguales\n',a,b);
end
Guardamos y ejecutando nuevamente tendremos:

>> mayor2n % ejecutando
Ingrese valor de a= 22
Ingrese valor de b= 22
a=22 y b=22 son iguales
67
Capítulo 3
switch … case … otherwise … end (Multibifurcación)

switch condición
case var=cte1;
<Sentencias2>;
case var=cte2;
<Sentencias3>;
.
.
.
case var=cteN
<SentenciasN>;
otherwise
<Sentencias por Defecto>;
end
Ejemplo ilustrativo:
Implementar un archivo script que calcule y muestre el valor respectivo de la función f para un valor
de x ingresado por el usuario, siendo la función de la siguiente forma:
Solución:
Implementamos en el editor las siguientes líneas de instrucción:
x=input('x= ');
switch x
case pi/5; f=sin(3*x)*exp(-x/2);

case 5; f=sqrt(x+5)*(x^2+5);
case 6.1; f=x^2.6;
otherwise; f=0;
end
fprintf('f(%4.3f)=%f\n',x,f)
68
Guardando el archivo con nombre valorf, ejecutamos y probamos:

>> valorf
x= pi/5
f(0.628)=0.694654
>> valorf
x= 6.1
f(6.100)=110.117811
>> valorf
x= 25
f(25.000)=0.000000
Estructura iterativa: Un bucle iterativo o iteración de una secuencia de instrucciones hace que se
repita su ejecución mientras se cumpla una condición. El número de iteraciones normalmente está
determinado por el cambio en la condición dentro del mismo bucle, aunque puede ser forzado o
explícito por otra condición. Por la forma de ejecución del bucle tenemos a la sentencia while, la cual
trabaja según la evaluación de condición, y a la sentencia for, que trabaja según el recorrido de un
contador.
while … end
while condición
<Sentencias>;
end
condición: Es una expresión lógica o relacional cuyo resultado es de tipo lógico, valor de 1 (uno) si
el resultado es verdadero ó 0 (cero) si el resultado es falso.
Sentencias: Son las sentencias a ejecutarse siempre y cuando la respuesta de la condición sea
verdadera.
69
Capítulo 3
Ejemplo:
Implementar un script que calcule la suma de los 10 primeros números naturales.
Solución: Escribimos en el editor las siguientes líneas de instrucción:
k=1;
suma=0;
while k<=10
suma=suma+k;
k=k+1;
end
fprintf('Suma10=%i\n',suma)
Guardando el archivo con el nombre suma10n y ejecutando, tendremos:

>> suma10n
Suma10=55
for … end
for rango(k)
<Sentencias>;
end
rango(k): Es el valor k-ésimo de rango que toma la variable contadora. Donde rango es un vector de
n elementos y debido a esto tendremos n iteraciones.
Sentencias: Son las sentencias a ejecutarse para cada uno de los valores del contador.
Si consideramos rango=[4 11 13], entonces tendremos 3 iteraciones y rango tomará el valor del
dato que se encuentra en la posición numéricamente igual al número de iteración. La primera para
k=1 tomará el valor de rango(1)=4, para la segunda iteración, es decir k=2, tomará el valor de
rango(2)=11 y para la tercera, k=3, tomará el valor de rango(3)=13.
70
Ejemplo: (igual al anterior)

Implementar un script que calcule la suma de los 10 primeros números naturales.
Solución: Escribimos en el editor las siguientes líneas de instrucción:
n=10;
suma=0;
for k=1:10
suma=suma+k;
end
fprintf('Suma10=%i\n',suma)
Guardando el archivo con el nombre suma10nf y ejecutando, tendremos:

>> suma10nf
Suma10=55
Sentencias especiales
continue (sentencia de salto)

Pasa el control a la siguiente iteración de los bucles for y while en el cual aparezca, salteando al
posible conjunto de sentencias del cuerpo del bucle que la sucedan.
for rango(k) El cuerpo del bucle for contiene una sentencia condicional
sentencias1; if que evalúa una condición.
if condición
sentencias2;
La sentencia de salto continue se ejecutará siempre que la
continue
evaluación de la condición resulte verdadera.
end Al ejecutarse continue se iniciará una nueva iteración,
sentencias3; salteando las instrucciones que preceden a continue, es
end decir a sentencias3.
break (sentencia de ruptura)

Termina la ejecución de un bucle for o while. Las sentencias que aparezcan después de esta sentencia
no se ejecutarán.
for rango(k)
sentencias1;
if condición
La sentencia de ruptura break al ejecutarse finalizará el
sentencias2;
ciclo del bucle for obviando la ejecución de las sentencias
break
posteriores, es decir las sentencias3.
end
sentencias3;
end
71
Capítulo 3
Ejercicios de Aplicación
1. Dado el vector v=[-1,3,6,11,-15,2,-7,-18], implemente un script que calcule y muestre los

valores de los resultados al sumar todos los números positivos y todos los números negativos.
Solución:
v=[-1,3,6,11,-15,2,-7,-18];
Sn=0; Sp=0;
for k=1:length(v)
if v(k)>=0
Sp=Sp+v(k);
else
Sn=Sn+v(k);
end
end
fprintf('Suma Positivos=%i\n',Sp)
fprintf('Suma Negativos=%i\n',Sn)
2. Implemente una función de nombre facto que calcule el factorial de un número cualquiera; el
programa deberá responder ante el ingreso del dato.
3. Implemente un script que calcule la sumatoria de los primeros n números cuadrados perfectos.
Solución:
n=input('n= ');
Scp=0;
for k=1:n
Scp=Scp+k^2;
end
fprintf('Suma=%i\n',Scp)
4. Implemente una función de nombre exponencial que calcule la aproximación de ex por la serie de
Maclaurin, con un error de 10-4, donde x y n son ingresados por el usuario.
5. Dada la ecuación de 2do grado: , implemente un script que calcule y muestre las
raíces de dicha ecuación y de qué tipo son dependiendo de su discriminante, donde a, b y c son
ingresados por el usuario.
Solución:
72
a=input('a= ');
b=input('b= ');
c=input('c= ');
d=b^2-4*a*c;
if d>0
disp('Raices Reales')
elseif d==0
disp('Raices Reales Iguales')
else
disp('Raices Complejas')
end
x1=(-b+sqrt(d))/2;
x2=(-b-sqrt(d))/2;
fprintf('x1=%8.6f\nx2=%8.6f\n\n',x1,x2)
6. Implemente un script que muestre en pantalla la siguiente lista de artículos de una tienda:
[1] Zapatos…………S.200.00
[2] Pantalones…….S.100.00
[3] Camisas………..S. 80.00
Y que el programa permita al usuario elegir el tipo de artículo a comprar, además que pueda
ingresar la cantidad que desea comprar. Finalmente el programa deberá mostrar el valor total a
pagar.
Ejercicios Propuestos
1. Escriba un programa que permita determinar si un número entero dado es par o impar. (Utilizar
el operador mod).
2. Utilizando el operador relacional > (mayor que), escriba un archivo.m que permita definir si un
número a es mayor que un número b. El programa debe admitir ingresar los números a y b, e
imprimir el resultado a es mayor que b, o a es menor que b, o a es igual a b.
3. Implemente un programa que permita ingresar un vector con N números y, posteriormente, permita
evaluar la media aritmética.
4. Implemente un programa que dé como resultado los números primos menores que un número
dado n (positivo y entero).
73
Capítulo 3
5. Imprima los múltiplos de 7 existentes entre dos valores m y n pedido al usuario. Modifique el
algoritmo para que calcule cuántos números hay y su suma.
6. Solicite al usuario dos números n y k y calcule (combinaciones de n elementos tomados de k en k).
7. Diseñe un algoritmo que permita calcular la posición (fila y columna) de la mayor componente de
una matriz pedida al usuario.
8. Realice un programa en Matlab que calcule el centro de masas de un sistema de partículas en
3D. Interés: Sumatorios y medias.
9. Cree un archivo.m que permita evaluar las series. Los argumentos de entrada son x y n, donde n
es el número de términos que se evalúan en la serie y x es un número real:
a)
b)
c)
74
4
Capítulo
Gráficos
MATLAB ofrece numerosas oportunidades para emplear rutinas que realicen gráficas en dos y tres
dimensiones, estas gráficas son alojadas en una ventana para su visualización donde existe una
paleta de comandos que permiten:
• Añadir texto en posiciones deseadas.
• Añadir flechas o líneas.
• Seleccionar alguna de las componentes del gráfico.
• Rotar el grafico a criterio deseado.
Las gráficas de MATLAB se pueden exportar a multitud de formatos gráficos puntuales y vectoriales
(jpg, bmp, tiff, eps, png). Además está la posibilidad de guardarlos con la extensión fig. En ese caso,
cuando se abre la figura se inicia la ejecución de MATLAB y se ofrece al usuario lafigura tal y como
estaba cuando la guardó, incluyendo modificaciones realizadas directamente sobre la ventana gráfica.
En lugar de dar instrucciones que se puedan ejecutar en la ventana de comandos, en este capítulo
principalmente implementaremos scripts que generen uno o varios gráficos al ejecutarse.
Ventana de Figura
Todas las gráficas realizadas en MATLAB deben alojarse en una ventana de figura que se identifica por
un nombre seguido de un valor de identificación, para invocarlo debemos escribir la siguiente sintaxis:
Ejemplo:
>> figure(8) % invocando a la ventana figura 8
Esta invocación responderá mostrando a la ventana figura 8:
75
Capítulo 4
Si al realizar una gráfica no precisamos una ventana figura en la cual alojarla, al ejecutar el programa
esta se alojará por defecto en la ventana figura 1.
Para cerrar una ventana figura n por comandos lo podremos hacer usando la función close(n);
el orden de cerrar las ventanas existentes no interesa, en caso no exista la ventana la función
closeretornará un mensaje de error.
>> close(8) % cerrando la ventana figura 8
Funciones de Gráficas en 2 Dimensiones

plot Grafico de líneas en el plano cartesiano, ubicando y uniendo los puntos con
segmentos de recta.
bar,barh Grafica parcela de barras verticales y horizontales
hist Grafica el histograma
stem Gráfico de bastones verticales, encierra a los puntos y los proyecta al eje x.
stairs Gráfica con trazos tipo escalonado.
polar Grafica las expresiones en coordenadas polares
pie Realiza gráficos de sectores.
rose Grafica el histograma angular, diagrama polar que muestra la distribución de
valores agrupados de acuerdo con su rango numérico
compass Grafica un conjunto de flechas con origen en (0,0), cuya magnitud y
dirección están determinadas por el módulo de z=x+iy
feather Dibuja un conjunto de flechas con origen en el eje "x", cuya magnitud y
dirección están determinada por el módulo de y.
loglog Realiza una gráfica cartesiana con escala logarítmica en los ejes
coordenados.
semilogx Realiza una gráfica cartesiana con escala logarítmica en el eje "x" y escala
normal en el eje y.
semilogy Realiza una gráfica cartesiana con escala logarítmica en el eje "y" y escala
normal en el eje "x".
fill Dibuja una región poligonal cuyos vértices son definidos por sus argumentos.
La función más estándar en ser utilizada es el plot. A continuación mostramos la característica de

sus sintaxis:
plot(dominio,rango,'características')
plot(D1,R1,'caract1',D2,R2,'caract2',…,Dn,Rn,'caractN')
76
La primera sintaxis realiza solamente una gráfica y la segunda es la forma para realizar hasta N
gráficas en un mismo eje cartesiano.
El argumento 'características' está conformado por 3 caracteres que especifican algunas
propiedades para la gráfica a realizarse con la función plot. El primer carácter nos especifica el tipo
de trazo a mostrar, el segundo especifica el color de línea y el tercer carácter especifica la marca del
punto.
Características de la Gráfica
Tipo de línea Color de Línea Tipo de Marca
- Continua b Azul . Punto
-- Discontinua r Rojo + Cruz
: Punteada g Verde o Circunferencia
-. Guión y Punto c Cian x Equis
x Equis m Magenta s Cuadrado
o Circunferencias y Amarillo d Diamante
+ Cruces k Negro p Pentagrama
Existen mucho más atributos que podemos asignar a las gráficas realizadas, como por ejemplo el
tamaño de la marca de punto, el color de fondo y del borde del mismo, así como el ancho de línea del
trazado. En el transcurso de las aplicaciones se irán mostrando algunos de estos para su futuro uso.
Graficas en 2D
Puntos: Para ubicar puntos en el plano cartesiano es necesario ubicar los valores de las abscisas de
cada par ordenado en un vector y sus respectivas ordenadas en otro vector teniendo en cuenta que
estas deben estar en la misma ubicación que ocupan sus abscisas.
Ejemplo:
Sean los siguientes puntos: , implemente un script para representar
dichos puntos en el plano cartesiano.
Solución: Siguiendo la definición dada escribimos las siguientes instrucciones:
x=[-2 1 3 6];
y=[-1 1 -2 3];
plot(x,y,'ro') % note que obviamos el 1er caracter
Lo guardamos con el nombre de grafo1.m, lo ejecutamos y visualizando la ventana figura tendremos

lo siguiente:
77
Capítulo 4
Debido a que le dimos solamente

atributos de color y marca de punto,
el plot nos muestra esta gráfica
que por defecto está alojada en la
ventana figura 1.
Note además que la extensión
del eje X y del eje Y lo asumió el
programa por defecto tomando los
valores mínimos y máximos de
cada vector. Si queremos ajustar
nuevas extensiones en los ejes,
debemos utilizar la función axis.
axis: Permite editar los ejes X e Y en extensiones deseadas.

Sintaxis: axis([xmin xmax ymin ymax])
Agregando la función axis en el script anterior, tendremos el siguiente resultado:

x=[-2 1 3 6];
y=[-1 1 -2 3];
plot(x,y,'ro')
axis([-3 7 -3 4])
78
MATLAB contiene funciones que nos permiten agregar algunas características para especificar la
gráfica saliente:
grid on, grid off Activa o desactiva el enrejado de los ejes.
xlabel('cadenax') Coloca la etiqueta cadenax al eje x.
ylabel('cadenay') Coloca la etiqueta cadenay al eje y.
title('cadena') Coloca el titulo cadena a la gráfica.
legend('cad_Leg') Coloca la leyenda cad_leg a la gráfica
axis([xo xf yo yf]) Sitúa los valores mínimos y máximos para los ejes
hold on, hold off Congela y descongela a la ventana figura para poder superponer
otra grafica en los mismos ejes.
text(x,y,'cadena') Ingresa automáticamente el texto cadena en el plano
cartesiano iniciando la escritura en (x,y)
gtext(x,y,'cadena') Ingresa manualmente (con mouse) el texto cadena en el plano
cartesiano iniciando la escritura en (x,y)
ginput(n) Importar n puntos de una gráfica con el mouse, dichos puntos
son almacenados en una variable asignada.
Por último, al archivo grafo1.m le damos sus atributos para mostrar una mejor salida de nuestra
gráfica, el usuario puede visualizar el código del archivo que se encuentra en el disco, teniendo como
resultado la siguiente gráfica:
79
Capítulo 4
Cartesianas:
Para hacer gráficas de funciones de una variable con MatLab, primero tenemos que crear una tabla
de valores de la variable para después dibujar la función. Debemos tener en cuenta que una curva es
la unión de infinitos puntos, debido a eso es necesario contar con una cantidad de datos necesarios
para realizar la simulación.
Ejemplo:
Realizar la gráfica de la siguiente expresión:
x=linspace(-1,5,30); % vector dominio
y=sin(x.^2); % vector rango
plot(x,y) % grafica por defecto
Guardando el archivo con el nombre grafo2.m y ejecutando, tendremos:
Notamos las imperfecciones de la curva debido a la poca cantidad de información, pero si aumentamos
la cantidad de puntos al vector x, ver código en el disco, tendremos una curva bastante suave con
respecto a la primera:
80
Ahora supongamos que queremos representar la función:
Para poder graficar f(x), generamos una tabla de valores en el dominio en el que queramos dibujar la
función y definimos la función, multiplicando cada trozo por el índice lógico que describa el lugar en
el que queremos dibujarlo.
Implementando en el editor las instrucciones a continuación y guardando el archivo con nombre
grafo3.m y ejecutando, tendremos:
x=linspace(-2,3,3000);
y1=(x.^2).*(x<0);
y2=1.*((0<=x)&(x<1));
y3=(-x+2).*(1<=x);
y=y1+y2+y3;
plot(x,y,'-b','linewidth',2)
grid on
title('Funcion definida a trozos','fontsize',16)
81
Capítulo 4
Utilizando las demás funciones para las gráficas tendremos lo siguiente:

stem: stairs:
>>x=-3:0.1:2*pi; >>x=0:0.1:2*pi;
>>y=exp(-x/2).*sin(2*x); >>y=sin(x);
>>stem(x,y) >>stairs(x,y)
bar: loglog:
>> x=0:0.1:pi; >> x=0:0.1:pi;
>> y=sin(x); >> y=sin(x);
>> bar(x,abs(y)) >> bar(x,abs(y))
Paramétricas:
Se observa que tanto el domino como el rango dependen de una variable.
Ejemplo:
Graficar la siguiente curva paramétrica:
Implementamos en un editor las siguientes instrucciones:

t=0:0.1:5*pi;
x=2*t.*cos(t);
y=2*t.*sin(t);
plot(x,y,'linewidth',2)
grid on
82
Guardamos el archivo con nombre grafo4.m y lo ejecutamos, entonces tendremos la siguiente curva
paramétrica:
Polares:
Ejemplo:
Graficar la siguiente curva polar: para
Solución:
Editando un archivo las instrucciones siguientes:
u=linspace(0,2*pi,360);
r=3-2*cos(3*u);
polar(u,r);
Guardamos con nombre grafo5.m y ejecutamos para ver la curva polar.
83
Capítulo 4
quiver: Permite crear los vectores velocidad en los puntos de una gráfica.
Sintaxis: quiver(x,y,z,dx,dy,dz)
Graficar los vectores velocidad sobre la curva:
Resolviendo en la ventana de comandos:

>> t=linspace(0,2*pi,20);
>>quiver(cos(t),sin(t),-sin(t),cos(t))
>>axis square
El número de vectores velocidad que aparecen es 20. Si el número de puntos que se indica con el
comando linspacees demasiado grande, puede que no se aprecie con claridad la gráfica, ya que ésta
será el número de vectores velocidad que se mostrará.
La gráfica resultante es:
El comando comet produce un resultado dinámico, la forma de ejecución es similar al plot, pero esta
vez aparece un circulito (el cometa) que va dibujando la curva. La velocidad de ejecución depende
del número de puntos que hayamos generado con el comando linspace.Ingrese las siguientes líneas
y verifique la salida gráfica que resulta de la aplicación.
>> t=linspace(-5,5,1000);
>> comet((t.*(t.^2-1))./(t.^2+1),(2*(t.^2-1))./(t.^2+1))
84
hist: pie:
>> x = -4:0.1:4; >> x = [1 3 0.5 2.5 2];
>> y = randn(length(x),1); >> explode = [0 1 0 0 0];
>> hist(y,x) >> pie(x,explode)
Gráficos Múltiples
La función plot puede realizar varias gráficas superpuestas en una misma ventana figura, las
propiedades las adopta el MATLAB si es que no son especificadas.
Ejemplo:
>> x=0:0.1:4;
>> y1=4*exp(-x).*sin(2*x);
>> y2=2*cos(x);
>> plot(x,y1,x,y2)
85
Capítulo 4
Utilizando la función hold antes de un nuevo comando que gráfica podemos superponer más gráficas
en una sola ventana figura.
>> x=0:0.1:5;
>> y1=3*sin(x);
>> y2=cos(x);
>> plot(x,y1)
>> hold on % congela la ventana
>> plot(x,y2)
>> grid on
>> hold off % descongela la ventana
subplot: Permite que una ventana figura pueda dividirse en varios ejes, dividiéndose en filas y columnas,
asignando a cada división un número identificador, permitiendo así alojar más de una gráfica.
Sintaxis: subplot(#filas,#columnas,posición)
Ejemplo:
Realizar la gráfica de las siguientes expresiones en una sola ventana figura.
a)
b)
c)
d)
86
Solución:
x=linspace(0,4,300);
y1=8*sqrt(x);
y2=6*sin(4*x);
y3=x.^2;
y4=10*exp(-x).*cos(4*x);
subplot(2,2,1)
plot(x,y1,'linewidth',2)
title('Curva 1')
subplot(2,2,2)
plot(x,y2,'linewidth',2);title('Curva 2')
subplot(2,2,3)
subplot(2,2,4)
Tenga en cuenta que cada gráfica está sujeta independientemente al manejo de sus diferentes
características, es decir: color, trazo, marca, etiqueta de ejes, título, leyenda, etc. Pueden ser
diferentes para cada gráfica.
87
Capítulo 4
Funciones de Gráficas en 3 Dimensiones
plot3 Grafica un conjunto de puntos en los ejes tridimensional.
fill3 Dibuja una región poligonal cuyos vértices son los elementos de
los vectores que representan a los datos en los ejes XYZ.
stem3 Grafica bastones verticales, iniciando desde el plano XY
comet3 Realiza el trazado de la curva en forma dinámica
bar3 Grafica de barras tridimensionales
pie3 Grafica sectores cilíndricos tridimensionales
mesh Grafica una superficie z=f(x,y)
meshc Grafica una superficie z=f(x,y) y proyecta las curvas de nivel en
el plano XY.
meshz Grafica una superficie z=f(x,y) cerrando la grafica con las
fronteras del dominio.
surf Grafica una superficie z=f(x,y) dando relleno de color a cada una
de las celdas.
surfc Grafica una superficie z=f(x,y) , proyectando las curvas de nivel
al plano XY
surfl Grafica una superficie z=f(x,y) considerando una iluminación en
formato básico.
waterfall Grafica una superficie z=f(x,y) en forma de cascada.
contour
contour3 Grafica las curvas de nivel en 2D y 3D
sphere Grafica una esfera unitaria.
cylinder Grafica una superficie de revolución para f(t) en el dominio t
ribbony Grafica una superficie z=f(x,y) como cintas tridimensionales
quiver3 Grafica los vectores velocidad en los puntos de las coordenadas
tridimensionales.
Puntos: En tres dimensiones debemos tener en cuenta que ahora cada punto tendrá tres coordenadas,
por lo tanto tendríamos tres vectores que alojan al conjunto de abscisas, ordenadas y altura.
Ejemplo:
Sean los siguientes puntos: , implemente un script para
representar dichos puntos en el plano cartesiano.
Solución: Generando el script grafo3D1.m, ubicarlo en el CD, podemos visualizar las siguientes
salidas:
88
plot3(x,y,z,'ro'): stem3(x,y,z,'r')
Cartesianas:
Cada valor para los ejes estará representado por 3 vectores del mismo orden.
Ejemplo:
Graficar la curva cartesiana representada por:
Solución:
Editando en un script de nombre grafo3D2.m las siguientes instrucciones:
x=linspace(0,10,300);
y=2*sqrt(x+1);
z=7*exp(-y/4).*cos(4*x);
plot3(x,y,z)
grid on
Ejecutando el archivo, tendremos la gráfica siguiente:
89
Capítulo 4
Paramétricas:
Ejemplo:
Realizar la gráfica de la siguiente expresión:
Solución: Implementando las siguientes líneas de instrucción:

t=linspace(0,5*pi,300);
x=3*t.*cos(t);
y=3*t.*sin(t);
z=t.^2;
plot3(x,y,z)
grid on
Guardando el archivo con el nombre grafo3D3.m y ejecutando, tendremos:
A partir de las formas de graficar mostradas hasta ahora, podemos deducir que el usuario ya cuenta
con las herramientas necesarias y suficientes para interpretar gráficamente cualquier expresión
matemática en coordenadas cartesianas, paramétricas y polares, ya sea en 2D o en 3D.
90
Superficies
MATLAB es mucho más práctico y funcional al momento de representar las superficies 3D, dispone de
una gran variedad de formatos para dibujar gráficas de funciones de dosvariables y una componente,
ya sea por mallado, líneas de contorno y cuadrículas de colores que son las usadas. Para visualizar
correctamente las superficies es adecuado y preciso que estén representados como funciones
definidas sobre un domino rectangular en cualquiera de los planos de referencia.
Para trabajar con regiones rectangulares, definiremos los vectores de abscisas y de
ordenadas , que representarán a los ejes, entonces la región de dominio rectangular
estará definida por el conjunto de coordenadas siguientes: ,
generando una matriz de orden n×m.
Para facilitar la creación del enrejado en MATLAB, utilizaremos la función meshgridque tiene
la siguiente sintaxis:
[xmatriz,ymatriz]=meshgrid(xvector,yvector)
Forma z=f(x,y)
Para graficar funciones de dos variables , al igual que para funciones de una variable,
primero hay que disponer de datos en una extensión del eje x y también otro conjunto de datosen
una extensión del eje y. Seguidamente tenemos que generar un mallado interceptando los datos en el
plano XY. Para ello utilizaremos la función meshgrid. A continuación mostramos un ejemplo:
>> x=-1:0.1:1; % orden: 1x21
>> y=-2:0.1:2; % orden: 1x41
>> [xm,ym]=meshgrid(x,y); % enrejado matriz de 21x41

Y finalmente expresaremos la función z con las variables enrejadas:
>> zm=exp(-xm.^2-ym.^2).*sin(-xm.^2-ym.^2);
Visualizar la superficie se puede lograr de las siguientes formas:

>> mesh(xm,ym.zm) ó >> surf(xm,ym,zm)
mesh(xm,ym,zm) surf(xm,ym,zm)
91
Capítulo 4
waterfall(xm,ym,zm) ribbon(xm,ym,zm)
surf(xm,ym,zm); shading flat surf(xm,ym,zm); shading interp
SOMBRAS Y COLORES Para conseguir efectos de sombreadosy colores diferentes se pueden consultar
todas las posibilidades de loscomandos colormap y shading. Algo que resulta también interesante es
añadir una escala de colores al dibujo, lo que nos permite conocer las alturas (coordenada z) de los
diferentes puntos de la gráfica, esto se consigue con el comando colorbar (después de dibujada la
gráfica). A continuación mostraremos el uso de estos comandos:
>>[x,y]=meshgrid(linspace(-1,1,50));
>>z=cos((x.*y)./(x.^2+y.^2+1));
>>surf(x,y,z)
>>shading interp
>>colorbar
Como se puede observar, los puntos más altos

corresponden a los colores más calientes y los
puntos más bajos de la gráfica están coloreados
con colores fríos.
92
ROTACIÓN DE GRÁFICA: Otros comandos interesantes en las gráficas 3D es la que manipulan la

vista de los ejes coordenados.
rotate3d nos permite activar la rotación de la vista utilizando el ratón sobre la figura, rotándola de
manera interactiva en tres dimensiones.
view: Especifica la posición del espectador (el punto de vista) determinando la orientación de los ejes. Se
especifica el punto de vista en términos de azimut y elevación, o por un punto en el espacio tridimensional.
view([az,el]) ó view([x,y,z])
Superficies Complejas
Sea la función compleja de variable compleja:
El comando cplxmap permite representar gráficas de funciones complejas de variable compleja,

dibujando una gráfica tridimensional en la que el eje X es la parte real de la variable ; el eje Y
es la parte imaginaria de la variable y el eje Z es la parte real de la imagen de la función, es
decir, .
La variable z debe pertenecer siempre al dominio constituido por el disco unidad con centro en el
origen y las coordenadas de los puntos deben estar en forma polar.
Esto se consigue utilizando previamente el comando cplxgrid(n), donde n es el número entero positivo.
Por ejemplo, para obtener la gráfica de la función realizaremos las siguientes líneas de instrucciones:
>>z=cplxgrid(12);
>>cplxmap(z,z.^2)
Obteniéndose lo siguiente:
Se observa que para cada valor de z, la

imagen es única. Esto no es así para
cualquier función compleja. Por ejemplo, la
función es una función bivaluada,
la función es una función trivaluada,
cada z puede producir tres valores distintos
para , y así sucesivamente.
93
Capítulo 4
Estadísticas
bar3: pie3:
>> x=[10 2 3 5 18 20 15 ]; >> x = [1 3 0.5 2.5 2];
>> bar3(x); >> explode = [0 1 0 0 0];
>> pie3(x,explode)
Superficies: Generados por Funciones

Hay varios comandos en MatLab que permiten generar las gráficasde superficies en R3 (superficies
que no son funciones.) Estos comandos son funciones que ya vienen programadas.
ESFERA
Se genera utilizando el comando

>>sphere(n),
donde n es el número de puntos en los que queda

dividido el ecuador de la esfera. Cuanto mayor sea n,
mayor sería la aproximación a la curvatura real dela
esfera (de radio 1, centrada en el origen).Poniendo
sólo >>sphere, el valor que tomará n sería 20, por
defecto. A continuación damos un ejemplo de cómo
realizar la gráfica de la esfera de la derecha:
>>sphere;axis square;title('ESFERA')
94
Vectores Normales a una superficie
Dibujar los vectores normales a la superficie de una esfera siguiéndolos siguientes pasos:
Dibujar una esfera utilizando lo descrito anteriormente,
pero guardando la información en tres variables:
>>[x,y,z]=sphere(30); %
Utilizar el siguiente comando:

>>surfnorm(x,y,z)
Este comando también se puede utilizar para dibujar

los vectores normales en superficies de funciones de la
forma z = f(x; y). Para dibujarlas normales en el sentido
opuesto habría que poner surfnorm(x',y',z').
CILINDRO
El comando >>cylinder(R,n) genera automáticamente un cilindro de revolución de radio R, donde

n es el número depuntos de la circunferencia de la base del cilindro. Como en el caso de laesfera, si
usamos sólo >>cylinder(R), el número n es, por defecto, 20.
Lo realmente interesante de este comando es que
también admiteradios variables R(t), con .
De esta forma, puede ser utilizado para obtener
las gráficas de diferentes tipos de superficies
de revolución,donde la generatriz es una función
definida por R(t). Por ejemplo, siqueremos dibujar
un paraboloide de revolución, podemos utilizar
comogeneratriz la función con ,
realizaremos lo siguiente.
>>t=linspace(0,2,20);
>>r=sqrt(t);
>>cylinder(r)
95
Capítulo 4
Geometría diferencial de curvas

En matemáticas, la geometría diferencial de curvas propone definiciones y métodos para analizar
curvas simples en Variedades de Riemann, y en particular, en el Espacio Euclídeo.
Longitud de arco
Dada una curva suficientemente suave (diferenciable y de clase ), en y dado su vector de

posición expresado mediante el parámetro ;
se define el llamado parámetro de arco como:
La cual se puede expresar también de la siguiente forma en la cual resulta más fácil de recordar
Lo cual permite reparametrizar la curva de la siguiente manera:
donde:
son las relaciones entre las dos parametrizaciones.
Vectores tangente, normal y binormal: Triedro de Frênet-Serret
Dada una curva parametrizada según un parámetro cualquiera se define el llamado vector
tangente, normal y binormal como:
96
Vista esquemática del vector tangente, vector normal

y vector binormal de una curva hélice.
Estos tres vectores son unitarios y perpendiculares entre sí, juntos configuran un sistema de referencia
móvil conocido como Triedro de Frênet-Serret a raíz del estudio de Jean Frenet y Joseph Serret. Es
interesante que para una partícula física desplazándose en el espacio, el vector tangente es paralelo
a la velocidad, mientras que el vector normal da el cambio dirección por unidad de tiempo de la
velocidad o aceleración normal.
Si la curva está parametrizada según la longitud de arco, como se explicó en la sección anterior las
fórmulas anteriores pueden simplificarse notablemente:
Donde los parámetros y anteriores designan precisamente a la curvatura y a la torsión.
Curvatura y torsión
La curvatura es una medida del cambio de dirección del vector tangente a una curva, cuanto más
rápido cambia éste a medida que nos desplazamos a lo largo de la curva, se dice, que más grande
es la curvatura. Para una curva parametrizada cualquiera la curvatura es igual a:
Si la curva está parametrizada por el parámetro de longitud de arco, la anterior ecuación se reduce
simplemente a:
Además de la curvatura se suele definir el llamado radio de curvatura, como el inverso de la curvatura.
97
Capítulo 4
La torsión es una medida del cambio de dirección del vector binormal: cuanto más rápido cambia,
más rápido gira el vector binormal alrededor del vector tangente y más retorcida aparece la curva.
Por lo tanto, para una curva totalmente contenida en el plano la torsión es nula ya que el vector
binormal es constantemente perpendicular al plano que la contiene. Para el caso general la torsión
viene dada por:
Si la curva está parametrizada por el parámetro de longitud de arco, la anterior ecuación se reduce a:
Plano osculador
En cada punto de una curva, el plano osculador es el plano que contiene al su vector tangente y al
vector normal a la curva. Para una partícula desplazándose en el espacio tridimiensional, el plano
osculador coincide con el plano que en cada instante contiene a la aceleración y la velocidad. La
ecuación de este plano viene dada por:
Donde:
, el punto de la trayectoria.
, el vector velocidad en el punto considerado.
, las coordenadas de un punto genérico del plano osculador.
Si se tiene una partícula en la posición , moviéndose con velocidad y sometida a una aceleración
, el plano osculador viene dado por el conjunto de puntos:
Obviamente si la partícula tiene un movimiento rectilíneo el plano osculador no está definido.
98
Centro de curvatura
Ilustración de la circunferencia osculatriz en el punto P de la curva C, en la que se muestra también

el radio y centro de curvatura.
En un entorno de un punto de una curva puede ser aproximado por un círculo, llamado círculo
osculador por estar contenido en el plano osculador. El radio del círculo osculador coincide con el
radio de curvatura (inverso de la curvatura). El centro de dicho círculo puede buscarse como:
O más sencillamente en función del parámetro de arco como:
Teorema fundamental de curvas
El teorema fundamental de curvas que enunciamos a continuación nos dice que conocido un punto
de una curva y su vector tangente, la curva queda totalmente especificada si se conoce la función de
curvatura y de torsión. Su enunciado es el siguiente:
Sea un intervalo. Dadas dos funciones continuas X y t de a y dado un sistema de
referencia fijo (ortonormal) de , {x0; e1, e2, e3}, entonces existe una única curva parametrizada de
, y tales que:
1. La curva pasa por x0, y el vector tangente T a la curva en ese punto coincide con e1.
2. A lo largo de la curva pueden definirse tres campos vectoriales T(s), N(s) y B(s) llamados
respectivamente vector tangente, normal y binormal, perpendiculares entre sí y tales que en el
punto inicial coinciden con e1, e2, e3 (es decir, T(0) = e1, N(0) = e2, B(0) = e3).
99
Capítulo 4
3. Se cumplen las siguientes ecuaciones:
O bien escrito matricialmente:
donde el punto es la derivada con respecto al arco parámetro s.

Esto tiene implicaciones físicas interesantes, por ejemplo, la trayectoria de una partícula queda
especificada si se conocen la posición inicial, la velocidad inicial y la variación en el tiempo de las
derivadas segundas (que están relacionadas con la curvatura y la torsión). Es por eso por lo que
las leyes de Newton o las ecuaciones de Euler-Lagrange se expresan en términos de derivadas de
segundo orden (que es necesario complementar con la posición y velocidades iniciales).
Se pide al usuario ejecutar el script tiedro_movil.m, circ_oscula.m, plano_osculador.m y
long_arco.m, luego ingresar los datos solicitados por el cada uno de los programas para obtener
las definiciones anteriores.
1. Dibuje las gráficas de las siguientes funciones eligiendo, en cada caso, una tabla de valores
adecuada para que aparezcan los aspectos más representativos de la función:
a)
b)
c)
d)
e)
f)
100
g)
h)
i)
2. Dibujar las siguientes curvas en paramétricas; en los apartados a) y b), dibujar además los
vectores velocidad utilizando el comando quiver:
a)
b)
c)
d)
e)
f)
g)
h)
3. Dibujar las siguientes curvas polares:

a)
b)
c)
d)
e)
101
Capítulo 4
f)
g)
h)
4. Graficar las siguientes curvas:

a)
b)
c)
d)
5. Representar las gráficas de las siguientes funciones de 2 variables, utilizando alguno de los
comandos descritos anteriormente. Dibujar también algunas curvas de nivel. Tome las extensiones
adecuadas para x e y.
a)
b)
c)
d)
6. Dibujar las superficies generadas por >>cylinder(R(t),30), en cada uno de los siguientes
casos:
a) ,
b) ,
c) ,
d) ,
102
5
Capítulo
Polinomios
En la actualidad los polinomios son utilizados en la mayoría de los cursos relacionados con la
programación de los métodos numéricos, justificando así la facilidad de manipulación y de
implementación en cualquiera de los lenguajes existentes. Es muy conocido también que en el área
de control existe la manipulación de polinomios de estados para representar el comportamiento a
través del tiempo de un sistema, y es ahí donde apuntamos el estudio de este capítulo.
Definición
Con MATLAB se puede trabajar con polinomios de forma sencilla.Es suficiente tener en cuenta que
un polinomio en el programa no es nada más que un vector que contiene los coeficientes de dicho
polinomio completo y ordenado descendentemente en su grado. Es decir, si tenemos la expresión:
Podemos representarlo en MATLAB de la siguiente manera:
Por ejemplo, si deseamos escribir los polinomios:

y
Sólo realizaríamos lo siguiente:
>> f=[3 0 1] % polinomio f de grado 2
f =
3 0 1
>>g=[2 0 -1 3] % polinomio g de grado 3

g =
2 0 -1 3
Si deseamos ver la expresión matemática de los polinomios haremos lo siguiente:

>> F=poly2sym(f) % expresión algebraica de f
F =
3*x^2 + 1
>> G=poly2sym(g) % expresión algebraica de g

G =
2*x^3 - x + 3
103
Capítulo 5
Toda matriz está asociada a un polinomio, la cual recibe el nombre de polinomio característico de la
matriz, y este se obtiene de la siguiente forma:
>>A=round(46*randn(4)); % matriz cualquiera
A =
25 15 165 33
84 -60 127 -3
-104 -20 -62 33
40 16 140 -9
>>pA=poly(A) % obtiene de polinomio característico de A

pA =
1.0e+007 *
0.0000 0.0000 0.0014 0.1266 3.5530
Las raíces de todo polinomio se hallan de la siguienteforma:

>>fr=roots(f) % vector columna de las raíces de f
fr =
0 + 0.5774i
0 - 0.5774i
>>gr=roots(g) % vector columna de las raíces de g

gr =
-1.2896
0.6448 + 0.8645i
0.6448 - 0.8645i
Si tenemos un vector cuyos elementos son las raíces de un polinomio cualquiera, entonces con la
función poly podemosconocer a dicho polinomio de coeficiente principal igual a 1. Sea el vector r:
>>r=[-1 2 -2 -1 3];
>>R=poly(r) % polinomio de raíces r
R =
1 -1 -9 1 20 12
>>r=[-1 2 -2 1 3];
>>R=poly(r) % polinomio de raíces r
R =
1 -3 -5 15 4 -12
La cantidad de elementos de un vector que representa a un polinomio está relacionada con el grado
de dicho polinomio, dicho grado se halla así:
>>gradoF=length(f)-1 % grado del polinomio F
gradoF =
2
>>gradoG=length(g)-1 % grado del polinomio G

gradoG =
3
104
Operaciones con polinomios
conv: Calcula el producto de 2 polinomios.

Sintaxis: var = conv(poly1,poly2)
Ejemplo: De los polinomios f y g definidos anteriormente, tendremos:

>>FG=conv(f,g) % producto de f con g
FG =
6 0 -1 9 -1 3
>>FG=conv(g,f) % producto de g con f

FG =
6 0 -1 9 -1 3
deconv: Calcula la división de 2 polinomios.

Sintaxis: cociente = deconv(poly1,poly2)
[cociente,resto] = deconv(poly1,poly2)
No debe olvidar que el grado de poly1 es mayor o igual al grado de poly2.

Ejemplo: De los polinomios f y g definidos anteriormente, tendremos:
>>cocienteGF=deconv(g,f)
cocienteGF =
0.6667 0
>>[cocienteGF,residuo]=deconv(g,f)
cocienteGF =
0.6667 0
>>residuo =
0 0 -1.6667 3.0000
Ahora, si deseamos sumar dos polinomios de diferentes grados, debemos tener en cuenta que
dichos polinomios serán representados en MATLAB como dos vectores de diferentes cantidades
de elementos, por lo tanto es imposible realizar la operación con el operador "+" de forma directa,
debido a esto, debemos aumentar una cantidad de ceros a la izquierda del vector de menor número
de elementos para tener la misma cantidad para ambos vectores, sólo así se verificará que la suma
es realizable. Las siguientes líneas de instrucciones posibilitan realizar la suma de dos polinomios de
diferentes grados.
105
Capítulo 5
function s=sumapol(p,q)
n=length(p)-1;
m=length(q)-1;
if n>m
q=[zeros(1,n-m) q];
else
p=[zeros(1,m-n) p];
end
s=p+q;
Guardando esta función creada con el nombre de sumapoly aplicando:

>>S=sumapol(g,f) % g+f
S =
2 3 -1 4
>>S=sumapol(f,g) % f+g
S =
2 3 -1 4
polyder: Calcula la derivada de un polinomio.

Sintaxis: var = polyder(poly)
Ejemplo: Siendo f, g y R polinomios definidos anteriormente, entonces:

>>df=polyder(f) % derivada del polinomio f
df =
6 0
>>dg=polyder(g) % derivada del polinomio g

dg =
6 0 -1
>>dR=polyder(R) % derivada del polinomio R

dR =
5 -12 -15 30 4
polyint: Calcula la primera integral de un polinomio.

Sintaxis: var = polyint(poly)
var = polyint(poly,k)
106
La primera sintaxis nos dará la integral con constante = 0 y la siguiente nos dará la integral con una
constante de valor k.
Ejemplo: Tomando los polinomios f y g ya definidos anteriormente:
>>If=polyint(f) % TérminoIndependiente = 0
If =
1 0 1 0
>>Ifk=polyint(f,2.6) % Término Independiente = 2.6

Ifk =
1.0000 0 1.0000 2.6000
>>Igk=polyint(g,-6) % Término Independiente = -6

Igk =
0.5000 0 -0.5000 3.0000 -6.0000
polyval: Evalúa a un polinomio en un valor o un conjunto de datos.

Sintaxis: var = polyval(poly,x)
Ejemplo: Tomando al polinomio f definido anteriormente, tendremos:

>> x=16;
>> fx=polyval(f,x)
fx =
769
>> x=12:17;
>> fx=polyval(f,x)
fx =
433 508 589 676 769 868
Si queremos graficar al polinomio en el dominio , implementaremos un script

con las siguientes instrucciones:
f=[3 0 1];
x=-5:0.1:5;
y=polyval(f,x);
plot(x,y,'-r') % graficando al polinomio
grid on
107
Capítulo 5
Guardando el archivo con el nombre poly_ejemplo.m y ejecutándolo, tendremos:
Ejercicios:
a) Sea las raíces de un polinomio de grado 3: , obtenga dicho polinomio

además de su gráfica para .
b) Halle la sumadel cociente y resto de las siguientes divisiones:
i)
ii)
iii)
Ajuste de curvas Bidimensionales
Si deseamos obtener un polinomio que se ajuste a nuestros datos experimentales teniendo la libertad
de elegir el grado de este, aplicaremos la siguiente función:
polyfit: Construye un polinomio de ajuste de grado n utilizando el método de los mínimos cuadrados
empleando los datos en el dominio y el rango.
Sintaxis: Pol = polyfit(datoX,datoY,grado)
108
Ejemplo: Utilizaremos la función rand para obtener datos cualquiera para X e Y.

>> x=7*rand(1,10);
>> y=26*rand(1,10);
>> Pajus=polyfit(x,y,1) % polinomio de orden 1
Pajus =
0.1427 9.5543
>> Pajus=polyfit(x,y,3) % polinomio de orden 3
Pajus =
0.0248 -1.6996 11.1710 -1.6257
Ejercicio:
Implemente un archivo script que grafique los polinomios de ajuste de 1°, 2°, 3°, 4° y además los
datos X e Y para un dominio , siendo estos los siguientes:
Solución: Ejecutando el archivo pol_ajuste.m del CD, tendremos lo siguiente:
Funciones de Interpolación
spline: Realiza la interpolación cúbica de datos.

Sintaxis: var = spline(datoX.datoY,x)
Utiliza una interpolación spline cúbico para encontrar var,los valores de la función dato Y subyacente
a los valores de la x interpolante. Para la interpolación, la variable independiente se supone que es la
dimensión final de datoY con los puntos de interrupción definidos por x
109
Capítulo 5
Ejemplo:
Las siguientes líneas guardadas como script de nombre interp_spline.m, generan una curva sinusoidal.A
continuación, las muestras de la estría sobre una malla más fina.
x=0:10;
y=sin(x);
xx=0:.25:10;
yy=spline(x,y,xx);
plot(x,y,'o',xx,yy)
El resultado gráfico será la siguiente figura:
interp1: Interpola datos en 1-D.

Sintaxis: yi=interp1(x,Y,xi,'metodo')
Interpola para encontrar yi, los valores de lafunción Ysubyacenteen los puntos en la xi vector o
matriz.X debe serun vector. Y puede serun escalar, un vector, o una matriz de cualquier dimensión,
además metodo es la forma de cómo se desea realizar la interpolación, siendo estas las siguientes:
nearest : Interpolación del vecino más cercano
linear : Interpolación lineal
cubic : Interpolación usando polinomio cúbico de tipo de Hermite.
Ejemplo: Las siguientes instrucciones guardadas con el nombre interp_INTERP1.m, generan una curva
sinusoidal gruesa e interpola sobre un eje de abscisas más fino.
x = 0:10;
y = sin(x);
xi = 0:.25:10;
yi = interp1(x,y,xi);
plot(x,y,'o',xi,yi)
110
El resultado gráfico será la siguiente figura:
Ejercicios:
1. Suponga que tiene el siguiente conjunto de puntos de datos:
Tiempo (s) Temperatura °F

0.0 72.5
0.5 78.1
1.0 86.4
1.5 92.3
2.0 110.6
2.5 111.5
3.0 109.3
3.5 110.2
4.0 110.5
4.5 109.9
5.0 110.2
a) Genere una gráfica que compare la conexión de los puntos de temperatura con líneas rectas
y con una spline cúbica.
b) Calcule los valores de temperatura en los siguientes instantes: 0.3, 1.25, 2.36 y 4.48,
usando interpolación lineal e interpolación con spline cúbica.
c) Compare los valores de tiempo que corresponde a estas temperaturas: 81, 96, 100 y 106,
usando interpolación lineal e interpolación con spline cúbica.
111
Capítulo 5
2. Efectúe un ajuste de 1°, 2°, 3° y 4°, mostrando las aproximaciones para x=3.1 y x=3.75
empleando los polinomios involucrados, finalmente muestre sus respectivas gráficas. La siguiente
tabla muestra los datos a ajustar:
x y
0.0 18
1.0 20
2.0 12
3.0 0
4.0 -10
5.0 -12
6.0 0
7.0 32
8.0 90
9.0 180
10.0 308
112
6
Capítulo
Interpolación
En la práctica de la ingeniería se utilizan mucho las tablas de datos, como en el caso de las tablas
de vapor saturado en la termodinámica. En la mayoría de los casos el dato necesario no se encuentra
explícito en la tabla sino entre dos valores de ésta, para lo cual es necesario estimarlo de entre
los valores que presenta la tabla en un proceso conocido como interpolación. La idea básica de
la interpolación es hallar un polinomio o función que cumpla con pasar por todos los puntos de un
conjunto de datos, y poder estimar los valores entre ellos por medio del polinomio.
POLINOMIOS DE LAGRANGE
Para ilustrar la interpolación por polinomios de Lagrange considérese un conjunto de datos de tres
puntos. El polinomio interpolador en este caso es:
Obsérvese que en el punto sólo queda el primer término con su numerador y denominador cancelándose
entre sí. Lo mismo sucede con los demás puntos, por lo que se ve que el polinomio cumple con la
condición de pasar por todos los puntos de datos. En general, para n puntos de datos, el polinomio
de Lagrange es:
(1)
Una forma mucho más sencilla de ver la ecuación 1 es en forma de código, el cual se muestra escrito
para MATLAB en las siguientes líneas:
p=0;
for k=1:length(x)
den=1;
L=[]; % termino de lagrange
for r=1:length(x)
if r~=k
xp=x; % hallando el numerador de L
xp(k)=[]; % elimino el termino k-esimo
num=poly(xp); % numerador: polinomio de x
d1=(x(k)-x(r));% denominador de L
den=den*d1;
end
end
L=num/den;
p=p+y(k)*L % Polinomio de Lagrange
end
113
Capítulo 6
Dicho código está guardado en el CD como un script de nombre polLAGRANGE.m.

A continuación se muestra un ejemplo para ilustrar la implementación del código anterior:
Ejemplo:
Se tiene el conjunto de datos {(1,1),(2,3),(3,-1),(4,0),(5.3),(6,2)}. Muestre el polinomio
interpolador de Lagrange y la gráfica que se calcula ejecutando el script polLAGRANGE.m
Solución:
Al ejecutarse el script obtenemos lo siguiente:
*** POLINOMIO DE LAGRANGE ***
Vector X= [1 2 3 4 5 6]
Vector Y= [1 3 -1 0 3 2]
Pl(x)=
5 4 3 2
11 x 47 x 371 x 1321 x 1709 x
----- - ----- + ------ - ------- + ------ - 43
120 24 24 24 20
¿Deseas Graficar [Y]/[N]? : Y

Fin del Programa
114
POLINOMIO DE INTERPOLACIÓN POR DIFERENCIAS DIVIDIDAS DE NEWTON
Para una cantidad mayor de nodos es mucho más sencillo utilizar el método clásico de las diferencias
divididas de Newton. Recordemos su definición, para dos nodos se llama diferencia dividida de orden
uno a:
Mientras que la diferencia dividida de orden n se obtiene por recurrencia a partir de las anteriores
como:
El polinomio de Newton en diferencias divididas es entonces:
El programa siguiente calcula las diferencias divididas.

for i=1:n-1
for j=n:-1:i+1
y(j)=(y(j)-y(j-1))/(x(j)-x(j-i));
fprintf(' %10.4f',y(j));
end
fprintf('\n');
end
Para los datos en x e y dados abajo, el resultado al aplicarse el código anterior puede verse en las
líneas siguientes. Los coeficientes del polinomio que hay que poner en la forma de Newton serían los
elementos de la columna vertical izquierda:
x =
-4 -2 0 2 4
y =
0.7568 -0.9093 0 0.9093 -0.7568
-0.8330 0.4546 0.4546 -0.8330

-0.3219 0.0000 0.3219
-0.0537 -0.0537
0.0000
115
Capítulo 6
Ejemplo:
Se tiene el conjunto de datos {(1,1),(2,3),(3,-1),(4,0),(5.3),(6,2)}. Muestre el polinomio
interpolador de Newton por diferencias divididas y la gráfica que se calcula ejecutando el script
newtoninterp.m
Solución:
Ingresando los vectores de datos y aplicando la función, tendremos:
>> x=[1 2 3 4 5 6];
>> y=[1 3 -1 0 3 2];
>> t=1:0.1:6;
>> p = newtoninterp(x,y,t);
116
Comparando las gráficas obtenidas por los dos métodos de interpolación: Lagrange y Newton,
tendremos que el error entre ambos es mínimo:
117
7
Capítulo
Resolución de Sistema
de Ecuaciones Lineales
En esta parte veremos cómo usar MATLAB para resolver sistemas de ecuaciones lineales. Al igual que
en la sección anterior usaremos tanto las rutinas internas de MATLAB como rutinaspropias creadas
por el usuario, asimismo las que se encuentran disponibles en la guía básica de MATLAB que se
encuentra en la página del curso. Pero además usaremos una combinación de los dos procedimientos.
Comencemos con las fáciles y sencillas rutinas internas de MATLAB: Si queremos resolverun sistema
de ecuaciones lineales, lo primero que debemos hacer es escribirlo en la forma matricial Ax=b.
Definición
Un sistema de ecuaciones lineales simultáneas de la forma:
.. ..
. .
Puede representarse mediante una matriz .

A partir de la matriz A y el vector b:
Se forma la matriz aumentada:
Esta matriz aumentada representa la ecuación vectorial

119
Capítulo 7
Por ejemplo, consideremos el sistema de ecuaciones:
Este sistema se puede escribir en la forma con:
Para resolverlo en MATLAB, primero definimos la matriz A y el vector b, así:

>> A=[2 -1 -1; 2 3 -1; 1 2 3];
>>b=[2;6;15];
Sabiendo que , realizamos en MATLAB lo siguiente:

>>x=inv(A)*b
Con lo cual obtenemos:

x =
3.1429e+000
1.0000e+000
3.2857e+000
Otra manera de llegar a esta solución es escribiendo en lugar de inv(A); sin embargo, la
manera más sencilla de hacerlo en MATLAB es escribiendo:
>> x = Ab
Donde el símbolo \ (división a izquierda), se usa en MATLAB para obtener la solución delproblema
.
De los varios métodos explicados hasta aquí para la solución de sistemas lineales usando MATLAB,
el que más se usa es el último, principalmente porque llega a la solución sin necesidad de hallar
la inversa de la matriz A (en realidad se usa factorización QR), lo que desde el punto de vista
computacional es bastante ventajoso. Se puede observar que el uso de este último método mejora la
velocidad de cálculo de MATLAB en cerca de un 50%.
Por último, sólo resta decir que en el caso de trabajar con matrices y vectores de componentes
enteras o racionales, es conveniente expresar los resultados de esta misma manera para evitar la
pérdida de cifras significativas. En MATLAB esto se puede hacer con la instrucción format rat, con la
que se aproximan todos los resultados a la fracción irreductible más cercana.
120
Para nuestro ejemplo:

>> format rat
>> x = A\b
Produce el resultado:
x =
22/7
1
23/7
Que es la solución exacta del sistema lineal.
APLICACIÓN A LOS CIRCUITOS ELÉCTRICOS
Muchos problemas pueden ser descritos mediante sistemas de ecuaciones lineales. Por ejemplo,
considere el circuito eléctrico mostrado en la figura siguiente:
Por la Ley de kirchoff, podemos dividir en mallas adecuadamente, donde las ecuaciones de malla que
describen a este circuito son las siguientes:
A partir de las ecuaciones de malla se pueden obtener todas las corrientes, voltajes y potencial delos
elementos del circuito. Por ejemplo, la corriente de la resistencia R es .
Definiendo R, i y v:
, y
Podemos expresar el juego de ecuaciones como:
121
Capítulo 7
Que puede representarse mediante la matriz aumentada:
La cual puede resolverse directamente como es en el caso anterior o utilizando los métodos de
iteración que a continuación conoceremos.
OPERACIONES ELEMENTALES DE REnGLÓN
Como la matriz aumentada representa un sistema de ecuaciones simultáneas, es posible realizar las
siguientes operaciones elementales de renglón manteniendo las igualdades de las ecuaciones representadas:
• Multiplicar un renglón por una constante.
• Multiplicar un renglón por una constante y sumarlo a otro renglón.
Los métodos de soluciones de sistemas de ecuaciones aplican estas operaciones sobre la
matrizaumentada en forma ordenada y repetida. En las siguientes secciones se explican los siguientes
métodos:
• Eliminación gaussiana (Gauss)
• Gauss-Jordan
• Montante
ELIMINACIÓN GAUSSIANA
Eliminación Gaussiana aplica operaciones de renglón para resolver un sistema de ecuaciones

simultáneas; su pseudocódigo se presenta a continuación, y en el CD su implementación en MATLAB
con el nombre Elim_Gauss.m.
122
Para cada renglón se define el elemento de la matriz aumentada como el pivote. Eliminación
Gaussiana opera en dos fases. Primero, para cada renglón empezando por el primer renglón, hace
ceros en los elementos debajo del pivote (líneas 3 y 4). Segundo, para cada renglón empezando por
el último renglón, hace el pivote igual a 1, y hace ceros arriba del pivote (líneas 5 a 8). La solución
al sistema de ecuaciones queda en la última columna de la matriz aumentada (línea 9).
A continuación, se presenta la solución del ejemplo del circuito eléctrico mediante eliminación
Gaussiana.
De donde se tiene que las corrientes de malla son:
Demostramos el resultado aplicando la función Elim_Gauss, cuya salida se muestra a continuación:

>> A=[15 -5 0;...
-5 15 -5;...
0 -5 20];
>> b=[20;0;0];
>> x=Elim_Gauss(A,b)
x =
1.5172
0.5517
0.1379
123
Capítulo 7
METODO DE GAUSS – JORDAN
En las líneas siguientes se muestra el seudocódigo método Gauss-Jordan, cuyo código está
implementado en el CD con nombre Gauss_Jordan.m.

El método de Gauss-Jordan es similar al de la eliminación Gaussiana, pero primero hace el pivote
igual a 1, y luego hace ceros en toda la columna del pivote. En el método de Gauss-Jordan primero
se hace el pivote igual a 1 (línea 3), después se hacen cero los elementos arriba y abajo del
pivote líneas 4 a 6). La solución al sistema de ecuaciones queda en la última columna de la matriz
aumentada en la última línea.
A continuación se muestra la solución del ejemplo del circuito eléctrico mediante el método de
Gauss-Jordan.
124
Demostramos el resultado aplicando la función Gauss_Jordan, cuya salida se muestra a continuación:

>> A=[15 -5 0;...
-5 15 -5;...
0 -5 20];
>> b=[20;0;0];
>> x=Gauss_Jordan(A,b)
x =
1.5172
0.5517
0.1379
PIVOTE MÁXIMO
Los algoritmos presentados pueden encontrar el problema de que el pivote sea cero, causando una
división entre cero. Para resolver este problema se pueden intercambiar renglones para colocar un
elemento diferente de cero en la diagonal principal. A continuación se presenta la implementación del
seudocódigo de Gauss-Jordan donde se escoge el elemento de máximo valor absoluto como pivote.
125
Capítulo 7
Método MONTANTE
El método de Montante resuelve un sistema de ecuaciones simultáneas haciendo operaciones que

mantienen el número de decimales que tiene los datos originales hasta el último paso, donde se
realiza la división entre el determinante.
Ejemplo del método Montante:
A continuación mostramos el seudocódigo del método montante:

El código fue implementado con el nombre Montante.m y se encuentra en el CD, aplicando tendremos
la siguiente salida:
>> A=[15 -5 0;...
-5 15 -5;...
0 -5 20];
>> b=[20;0;0];
>> x=Montante(A,b)
x =
1.5172
0.5517
0.1379
126
MATRIZ INVERSA
Los métodos de eliminación Gaussiana, Gauss-Jordan, y Montante pueden ser utilizados para encontrar
la inversa de una matriz. En este caso, la matriz aumentada sería la matriz original y la matriz identidad.
La inversa es la última n columnas de la matriz aumentada:
Demostrando el cálculo de la inversa por el método Montante tendremos:

>> A=[15 -5 0;...
-5 15 -5;...
0 -5 20];
>> I=eye(3);
>> Inversa=Montante(A,I)
Inversa =
0.0759 0.0276 0.0069
0.0276 0.0828 0.0207
0.0069 0.0207 0.0552
MéTODOS ITERATIVOS: JACOBI
Dado un sistema de ecuaciones de la forma:
127
Capítulo 7
Si se despeja la variable de cada ecuación se obtiene lo siguiente:
El sistema anterior puede usarse como una fórmula recursiva, además puede usarse para obtener los
valores de xi siguientes en función de los valores de xi actuales.
Si definimos la matriz T y el vector c de la siguiente manera:
Se pueden escribir las ecuaciones recursivas en forma matricial:
En las siguientes líneas se muestra el seudocódigo del método de Jacobi.
El código de este método se encuentra en el CD con el nombre Jacob.m
128
Métodos Iterativos: Gauss-Seidel
En las ecuaciones recursivas es posible utilizar inmediatamente los valores obtenidos para calcularlos
siguientes valores, es decir:
El utilizar los valores de xi que se acaban de calcular para calcular los siguientes valores permite que
el método converja más rápidamente a una solución.
Las ecuaciones recursivas se pueden escribir en forma matricial de la siguiente manera:
Donde representa la fila de la matriz , y la regla debe aplicarse en orden para =1,2,…,n
A continuación se muestra el seudocódigo:
129
Capítulo 7
Ejemplo de Método de Jacobi y Método de Gauss-Seidel

Para el ejemplo del circuito eléctrico se tiene que:
Y aplicando las funciones creadas para ambos métodos tenemos lo siguiente:

>> A=[15 -5 0;-5 15 -5;0 -5 20];
>> b=[20;0;0];
>> X0=[0;0;0]; % vector de valoresiniciales
Por Método de Jacobi:

>> [X,Iter]=Jacob(A,b,X0)
c =
1.3333
0
0
T =
0 0.3333 0
0.3333 0 0.3333
0 0.2500 0
X =
1.5170
0.5509
0.1377
Iter =
9
Por Método de Gauss-Seidel:

>> [X,Iter]=Gauss_Seidel(A,b,X0)
c =
1.3333
0
0
T =
0 0.3333 0
0.3333 0 0.3333
0 0.2500 0
X =
1.5170
0.5516
0.1379
Iter =
5
En general, Gauss-Seidel es más rápido que Jacobi, es decir, converge en menos iteraciones a la
solución correcta.
130
1. Dado los siguientes circuitos:
Utilizando mallas y Ley de Kirchoff, plantear las ecuaciones de cada circuito que representan a su
solución y resolverlos utilizando los métodos de Gauss-Seidel y Jacobi, compare los resultados.
2. Aplicando la función Elim_Gauss.m, Gauss_Jordan.m y Gauss_Seidel.m, implementados

anteriormente y que se encuentran en el CD, resolver si es posible el siguiente sistema de
ecuaciones lineales, compruebe sus resultados reemplazando las soluciones en las ecuaciones.
3. Dado el siguiente sistema de ecuaciones:
Y tomando como punto inicial lleve a cabo 4 iteraciones de Jacobi y de Gauss-Seidel.

4. Resuelva (si es posible) los siguientes sistemas lineales usando los métodos de Jacobi y Gauss-
Seidel. En todos los casos verifique si los teoremas garantizan convergencia de los métodos.
131
Capítulo 7
5. Use los métodos de Jacobi y Gauss-Seidel para resolver los sistemas:
6. Dada la siguiente matriz:
Encuentre su inversa mediante Gauss-Jordan y Montante. En ambos casos, utilice la opción de

pivote máximo. Compruebe sus resultados realizando la multiplicación AA–1.
132
8
Capítulo
Solución de Ecuaciones
No Lineales
En este capítulo usaremos el programa MATLAB con el fin de resolver ecuaciones no lineales de
manera rápida y fácil. Se usarán tanto las herramientaspropias de MATLAB, como rutinas creadas por
el usuario que nos llevarán paso a paso a lasolución de problemas.
Definición del Problema
Dada una ecuación de una variable independiente x:

(1)
Se desea encontrar el valor o valores de x que hacen que se cumpla la igualdad anterior, donde en
general, f es una función no lineal de x, es decir, que no puede expresarse como x
donde y son constantes. A los valores de x que hacen que se cumpla la igualdad se les denomina
raíces de la ecuación 1.
Método de la Bisección
También conocido como el método de las bisecciones sucesivas, comienza con un intervalo
donde se sabe que existe una raíz de la ecuación, y por lo tanto se debe cumplir que:
(2)
Este intervalo se divide a la mitad calculando:
Al encontrar el punto medio del dominio de x, podemos deducir que la raíz se encuentra en una de las
dos mitades, entonces debemos descartar una de ellas, entonces es necesario conocer el algoritmo
general del método de la bisección:
133
Capítulo 8
Método de la Bisección
Ejemplo: Determine valores aproximados de las soluciones positivas de la ecuación.
Solución:
Utilizando el archivo met_bisección.m, que se encuentra en el CD e ingresando los datos solicitados,
obtenemos la siguiente gráfica y resultado en pantalla:
134
***Metodo de la Bisección
f(x)= 0.5*exp(x/3)-sin(x)
x1= 0.25
x2= 1
Tolerancia= 0.0001
Los resultados son:
k=
X1= X= X2=
1 0.250000 0.625000 1.000000
2 0.625000 0.812500 1.000000
3 0.625000 0.718750 0.812500
4 0.625000 0.671875 0.718750
5 0.671875 0.695313 0.718750
6 0.671875 0.683594 0.695313
7 0.671875 0.677734 0.683594
8 0.671875 0.674805 0.677734
9 0.674805 0.676270 0.677734
10
0.676270 0.677002 0.677734
11
0.677002 0.677368 0.677734
12
0.677002 0.677185 0.677368
13
0.677185 0.677277 0.677368
14
0.677185 0.677231 0.677277
Raiz= 0.677231
Desea ver gráfica? [y]/[n]: y

fin de programa
Se observa que para la iteración número 14 la raíz aproximada cumple con el margen de tolerancia
requerida, tal como podemos observar en la gráfica anterior obtenida.
135
Capítulo 8
Ejercicio propuesto:
1. Calcule las 3 raíces de la siguiente ecuación no lineal:
Donde se sabe que las raíces se encuentran en los intervalos siguientes: [1 , 2.25], [2.25 , 4]
y [4 , 5]. La tolerancia es de .
Método de Punto fijo (iteración simple)
En el método de punto fijo, la ecuación se transforma a la forma , y ésta se utiliza

como una regla recursiva, es decir,
O lo que es lo mismo:
En la figura siguiente se muestra un ejemplo de la forma en que trabaja el método de punto fijo. El
método de iteración simple converge a una raíz de la ecuación si y son continuas
en un intervalo alrededor de r, si:
Para todo ese intervalo, y si se escoge en ese intervalo. Nótese que ésta es una condiciónsuficiente,
pero no necesaria.
Método de Punto Fijo
136
A continuación mostramos el pseudocódigo de este método:
Ejemplo:
El factor de fricción para los fluidos turbulentos en una tubería está dado por:
Llamada correlación de Colebrook, donde es el número de Reynolds, es la asperezade la

superficie de la tubería y D es el diámetro de la tubería. Resuelva la ecuación parafutilizando el
método de punto fijo para los siguientes casos:
a)
b)
Solución:
Si queremos resolver el problema empleando el método de punto fijo debemos llevar la ecuación a
la forma: .
Para ello llamamos , y así:
Luego la función:
Puede ser una posible función de iteración de punto fijo para .
Como queremos encontrar un punto fijo graficamos la función y la recta y=x para tomar un valor
inicial. Empecemos con el caso (a) donde:
137
Capítulo 8
Verifiquemos la representación de gráficamente.

Para graficar utilizamos las siguientes instrucciones:
>> fplot('1.14-2*log10*(0.025+3.1167*10^(-4))',[-2 2 -2 2])
>> grid on
>> hold on
>> fplot('1*x',[-2 2 -2 2])
Donde hold on permite graficar varias funciones en un mismo sistema coordenado.
De la gráfica anterior podemos ver que la función gcumple las condiciones del TeoremaFundamental
de Punto Fijo (¿dónde y por qué?). Para emplear el método tomaremos lamisma tolerancia para la
distancia entre las aproximaciones y emplearemos una funciónde punto fijo para MATLAB que seha
creadoen el editor por el usuario de nombre met_puntofijo.m, cuyo código se encuentra en el CD.
Si aplicamos esta función obtendremos lo siguiente:
>>met_puntofijo('1.14-2*log10*(0.025+3.1167*10^(-4))',1,0.000001)
it.
x g(x)
0
1.0000000000 1.0893766600
1
1.0893766600 1.0848521150
2
1.0848521150 1.0850811625
3
1.0850811625 1.0850695674
4
1.0850695674 1.0850701544
La aproximación del punto fijo es 1.0850701544
Luego el valor para f lo obtenemos de:
Lo mismo hacemos para resolver el caso b.

138
Método de Newton-Rapson
El método de Newton-Rapson se debe inicializar en un valor de x cercano a una raíz. El método

asume que la función es aproximadamente lineal en ese valor y, por lo tanto, toma como una mejor
aproximación a la raíz en la intersección de la línea tangente a y su intersección con el eje
x,como se muestra en la figura siguiente:
Método de Newton-Rapson
De la figura podemos ver que:
De donde tenemos la regla recursiva:
O lo que es lo mismo:
Tomando la idea de la condición de convergencia de iteración simple, la condición para Newton-

Rapson es la siguiente:
Que es equivalente a:
139
Capítulo 8
De nuevo, esta es una condición suficiente, pero no necesaria.

Mostramos el pseudocódigo:
Ejemplo:
Calcule las 3 raíces de la siguiente ecuación no lineal: , para un valor inicial
de y tolerancia de .
Solución:
Aplicando el script met_newton.m que se encuentra en el CD, obtenemos lo siguiente:
***Metodo de Newtón-Cotes
f(x)= pi*sin(2*x)+exp(-x/2)*cos(x)
x= 3.5
Tolerancia= 0.0001
Los resultados son:

k= F(X)= X= dF(X)=
1 1.901253 3.500000 4.879230
2 -0.407304 3.110338 6.369840
3 0.000835 3.174280 6.378647
Raiz= 3.174280

fin de programa
140
Gráfica de la función y de la solución de la ecuación no lineal.
Método de la secante
El método Newton-Rapson requiere evaluar f_(x). En el método de la secante, la derivadase aproxima

Sustituyendo en la ecuación recursiva de Newton-Rapson se obtiene:
O lo que es lo mismo,
Por lo tanto, el seudocódigo será:

141
Capítulo 8
Ejemplo:
Resolviendo el ejemplo anterior, teniendo en cuenta que inicialmente , aplicando el script
met_secante.m que se encuentra en el disco, tendremos lo siguiente:
***Metodo de la Secante***
f(x)= pi*sin(2*x)+exp(-x/2)*cos(x)
x= 3.5
xant= 2.5
Tolerancia= 0.0001
Los resultados son:

k= F(X)= X= Xant=
1 1.901253 3.500000 2.500000
2 -0.279696 3.130346 3.500000
3 0.022980 3.177753 3.130346
4 0.000026 3.174153 3.177753
5 -0.000000 3.174149 3.174153
Raiz= 3.174149

fin de programa
142
Newton-Rapson para funciones de más de una variable
El método de Newton-Rapson puede generalizarse para funciones de dos variables de la siguiente

manera. Supóngase que se desea encontrar los valores de x e y que hagan que se cumplan las
siguientes dos ecuaciones no lineales:
Dado un punto inicial , el método Newton-Rapson toma los planos tangentes a

y , y su intersección con el plano como el siguiente punto para continuar el método en
la siguiente iteración. La ecuación del plano tangente a es la siguiente:
(1)
Donde:
y
De la misma manera, la ecuación del plano tangente a es la siguiente:

(2)
Donde:
y
Sustituyendo z=0 en las ecuaciones 1 y 2 se obtiene el siguiente sistema de ecuaciones:
Donde se ha abreviado como , y de la misma manera para , y . Las ecuaciones

anteriores pueden expresarse en forma matricial de la siguiente manera:
(4)
Donde:
(5)
(6)
143
Capítulo 8
De las ecuaciones 4,5 y 6 se obtiene la regla recursiva para el método Newton-Rapson para dos
variables:
Donde y se obtienen de resolver el sistema de ecuaciones:
Ejemplo de dos variables

Encontremos una raíz del siguiente sistema de ecuaciones no lineales:
Obtenemos las derivadas parciales:
El sistema de ecuaciones es:
Tomemos :
De donde Δx = –1 y Δy = 0 por lo tanto:
Iterando tendremos los siguientes valores:

x 2 1 0.7500 0.7083 0.7071
y 1 1 0.7500 0.7083 0.7071
144
Para demostrar estos resultados, nos ayudaremos del archivo script newtonnl.m, que ejecutando en la
ventana de comandos e ingresando lo requerido por el programa nos mostrará lo siguiente:
>> newtonnl
Ingrese las funciones

f1(x,y)= x^2+y^2-1
f2(x,y)= x-y
Ingrese valores iniciales:
X0= [2;1]
Tolerancia= 0.0001
Max.Iter= 100
n=1 x=2.0000000 y=1.0000000

n=2 x=1.0000000 y=1.0000000
n=3 x=0.7500000 y=0.7500000
n=4 x=0.7083333 y=0.7083333
n=5 x=0.7071078 y=0.7071078
Ejercicios propuestos
1. Encuentre una raíz positiva de , que sea exacta hasta la segunda cifra
significativa.
2. Encuentre una raíz de:
en el intervalo [5.5 ,6.5]. Cambie -36 por -36.001 y repita el ejercicio.

3. Escriba un programa que ejecute el método de Newton, resuelva la ecuación . Encuentre
las raíces más cercanas a 4.5 y 7.7.
4. El polinomio tiene ceros 1,3 y -98. El punto debería ser en
este caso un buen punto inicial para calcular cualquiera de los ceros pequeños por medio de la
iteración de Newton.
5. Use el método de Newton para calcular la única raíz de:
Use una variedad de valores de B=1,5,10,25 y 50. Entre las elecciones del punto de partida
tome y explique el comportamiento anómalo. Teóricamente, el métodode Newton debe
converger para cualquier valor de y B.
145
Capítulo 8
6. Resuelva por el método de Newton para sistemas no lineales el siguiente sistema:
Use valores iniciales y .

7. Comenzando en (0, 0, 1), resuelva por el método de Newton para sistemas no lineales con el
sistema:
Explique los resultados.

8. Use el método de Newton para encontrar una raíz del sistema no lineal:
146
9
Capítulo
Integración
Los métodos de integración numérica nos permiten integrar funciones que están definidas
analíticamente o de las que sólo conocemos su tabla en un número finito de puntos.
Considerando el siguiente caso:
Dada una función se desea calcular la integral definida:
(1)
Para valores dados de y .
Todos los métodos que veremos se basan en evaluar la función para valores de x y aproximar el
área bajo la curva mediante estos puntos. El método más sencillo consiste en aproximar el área bajo
la curva mediante rectángulos, como se muestra en la figura siguiente:
El área del i-ésimo rectángulo es:
Si asumimos que la función va ser evaluada en puntos uniformemente espaciados, es decir que
es constante para toda , entonces podemos escribir como:
El área total es entonces igual a:
147
Capítulo 9
Método de los Trapecios
Podemos obtener una mejor aproximación al valor de la integral definida si aproximamos el área
mediante trapecios, como se muestraen la figura siguiente:
El área del i-ésimo trapecio es:
De nuevo, asumimos que el espaciamiento de los datos es uniforme e igual a h, por lo tanto:
Como ejemplo consideramos la función , se pide calcular la integral para un dominio

con 50 nodos.
Solución: Implementando un script de nombre I_trap.m, cuyo código mostramos a continuación y
ejecutando, obtenemos:
x=linspace(0,pi,50);
y=sin(x);
n=length(x)-1;
h=x(2)-x(1);
An=0;
148
for k=2:n
An=An+2*y(k);
end
A=(h/2)*(y(1)+y(n+1)+An);
fprintf('Area=%7.4f\n\n',A)
>> I_trap % ejecutando
Area= 1.9993
El usuario puede utilizar y resolver diferentes integrales definidas, utilizando la función trapz, propia
del programa o de la función trap_comp.m que se encuentra en el disco.
Método de Romberg
Suponga que se calcula numéricamente la integral de para un valor h1 = h, llamémosle R(1,1)

al valor obtenido. Si después se calcula la integral para h2 = h1/2, llamémosle R(2,1), podemos
obtener una mejor estimación del valor de la integral asumiendoque el error es proporcional a h2:
Si eliminamos la constante C podemos despejar el valor estimado para obtener lo siguiente:
Donde le hemos llamado R(1,2) al valor estimado. Ahora, supongamos que obtenemos laintegral de
para h3 = h/4, llamémosle R(3,1). Podemos calcular un valor estimado dela misma manera,
obteniendo que:
Ahora, podemos obtener una mejor estimación del valor de la integral utilizando R(1, 2) y R(2, 2)
De lo anterior, podemos deducir el método de Romberg. Dado un valor inicial de h, se calcula la

integral de f(x) para valores de paso de h, h/2, h/4, h/8, etc., (que es equivalente a que el número
de trapecios sea igual a n, 2n, 4n, 8n, etc.). Al valor de estas integral les llamamos R(1,1), R(2,1),
R(3,1), R(4,1), etc. Con cada valor de R podemos obtener una estimación mejor asumiendo que el
error es proporcional al cuadrado del paso utilizado mediante la fórmula:
149
Capítulo 9
Los valores de R pueden ordenarse en una tabla al estilo de diferencias divididas como se muestra
a continuación:
R(1,1) R(1,2) R(1,3) R(1,4) R(1,5)
R(2,1) R(2,2) R(2,3) R(2,4)
R(3,1) R(3,2) R(3,3)
R(4,1) R(4,2)
R(5,1)
El algoritmo continúa evaluando valores de R(i,1) hasta que la diferencia del valor absoluto entre
las últimas dos estimaciones de mayor orden obtenidas sea menor que una tolerancia que escoge
el usuario.
El Método de Romberg se utiliza junto con el método de trapecios para obtener una buena aproximación.
Ejemplo:
Con el script Metodo_Romberg.m, que se encuentra en el disco, podemos calcular la integral anterior,
cuyo resultado luego de ejecutarlo en la ventana de comandos mostramos:
f(x)=sin(x)
Extremo Inferior
a=0
Extremo Superior
b=pi
Cifras de Aproximacion
n=4
An =
0.0000 0 0 0
1.5708 2.0944 0 0
1.8961 2.0046 1.9986 0
1.9742 2.0003 2.0000 2.0000
Integral:
I= 2.000006
Método de Simpson 1/3
El método de Simpson 1/3 aproxima el área bajo la curva de f(x) mediante parábolas, como se
muestra en la figura siguiente:
150
Se hace pasar un polinomio de segundo orden por cada tres puntos. El polinomio definido por los
puntos xi–1 , xi , y xi+1 puede obtener mediante el polinomio de interpolación de Newton:
Donde:
Nótese que los coeficientes a1, a2 y a3 varían de segmento a segmento y, por lo tanto, que el
polinomio P2(x) es diferente para cada intervalo de tres puntos.
Para simplificar el cálculo del área bajo la curva en el intervalo de xi–1 a xi+1 , esto es Ai , se traslada
la curva a x=0 como se muestra en la figura siguiente:
Por lo tanto, el área Aj está dada de la siguiente manera:
Entonces el área por el método de trapecio es:
151
Capítulo 9
Por lo tanto, el área total es (Método de Trapecio Compuesto):
Ejemplo:
Utilizando el método de simpson 1/3 calcular la siguiente integral:
Solución: Aplicando la función met_simpson13.m que se encuentra en el disco, obtendremos lo

siguiente:
>>[I,E]=met_simpson13('x^5',0,1,50)
I =
0.1667
E =
1.0453e-007
Método de Simpson 3/8
El método de Simpson 3/8 aproxima el área bajo la curva de f(x) mediante polinomioscúbicos. Por
cada cuatro puntos se hace pasar un polinomio de tercer orden. Para los puntos xi , xi+1 , xi+2 , xi+3 el
área bajo la curva es:
Y el área total es:
Del ejemplo anterior y aplicando el script met-simpson38.m, tenemos:

***Metodo de Simpson 3/8***
f(x)= x^5
a= 0
b= 1
#Cifras Signif Exac.= 4
El valor de la integral aproximada es: 0.1667
152
Funciones de Cuadratura
MATLAB cuenta con dos funciones de cuadratura para realizar integración numérica de funciones:
quad y quad8. La primera utiliza una forma adaptativa de la regla de Simpson y la segunda usa la
regla de Newton-Cotes adaptativas de 8 paneles; esta última es la mejor para manejar funciones con
cierto tipo de singularidades, pero eso sí, ambos exhiben un mensaje de advertencia si detectan una
singularidad, devolviendo de todos modos una estimación de la integral.
Las formas más sencillas de estas dos funciones requieren tres argumentos. El primero es el
nombre (entre apóstrofos) del m-file función que devuelve un vector de valores de f(x) cuando se
le proporciona un vector de valores de entradas. La función puede ser una creada por el usuario o la
que está definida en el programa, el segundo y tercer elemento son los límites de integración a y b.
A continuación mostramos la sintaxis de estos:
var = quad('nombre_funcion',a,b)
var = quad8('nombre_funcion',a,b)
Ejemplo:
Calcular la integral de:
Solución:
Analíticamente el resultado es el siguiente:
A fin de comparar qué tanta aproximación tiene el resultado de las funciones de cuadratura, usamos
el siguiente script de nombre cuadrat.m
a=input('Extremo Inferior: ');
b=input('Extremo Superior: ');
I=(2/3)*(b^1.5-a^1.5);
Iq=quad('sqrt',a,b);
Iq8=quad('sqrt',a,b),
fprintf('Analitico= %f\nNumerico: %f\t%f\n\n',I,Iq,Iq8)
Ejecutando el programa para los valores solicitados, tendremos lo siguiente:

Extremo Inferior: 0
Extremo Superior: 5
Iq8 =
7.4536
Analitico= 7.453560
Numerico: 7.453556 7.453556
153
Capítulo 9
Ejercicio:
Un sistema de tubería fluye petróleo, donde la fricción en la tubería origina un perfil de velocidades en
el petróleo al fluir. El petróleo que está en contacto con las paredes no se está moviendo, mientras
que el petróleo que está en el centro del flujo se está moviendo con velocidad máxima:
y cuya ecuación se describe a continuación:
Entonces la velocidad media en el tubo es la integral del área de perfil de velocidad,lo cual se
demuestra que es:
Donde ro es el radio del tubo.

Con n=8 y ro=0.5m escriba un programa que integre el perfil de velocidad para calcular la velocidad
de flujo medio en el tubo.
Gráfica del perfil de velocidad de un oleoducto:
154
10
Capítulo
Solución de Ecuaciones
Diferenciales Ordinarias
Una ecuación diferencial ordinaria lineal de la forma:

con
se puede utilizar como modelo matemático de una gran variedad de fenómenos, ya sean físicos o no
físicos, y en disciplinas científicas y no científicas. Ejemplo de dichos fenómenos incluyen problemas de
transferencia de calor (termodinámica), circuitos eléctricos simples (ingeniería eléctrica), problemas
de fuerza (ingeniería mecánica), razón de crecimiento de bacterias (ciencias biológicas), razón de
descomposición radioactiva (física atómica), tasa de crecimiento de una población (estadística),
etc. Existe una serie de métodos para resolver este tipo de ecuaciones, dentro de los que podemos
mencionar: separación de variables, solución exacta y solución de series finitas. Dentro de estos
últimos, veremos los métodos de Euler y Runge-Kutta, segundo y cuarto orden.
Método de Euler
Dada una ecuación diferencial ordinaria de la forma:
se hace la aproximación: , de donde se tiene que:
Tomando se obtiene la regla recursiva del método de Euler:
Se requiere una condición inicial:
Entonces el término para el cálculo de la solución es:
155
Capítulo 10
Diseñamos una función que nos permita solucionar numéricamente una EDO empleando dicha
representación. Esta función tendrá la siguiente sintaxis:
% Metodo de Euler
function [t,y]=met_Euler(y0,t0,tf,h)
t=t0;
y(1)=y0;
k=1;
while t(k)<tf
t(k+1)=t0+k*h;
y(k+1)=y(k)+h*fcn(t(k),y(k));
k=k+1;
end
Donde: fcn, es la función que representa a la ecuación diferencial y deberá ser definida cada vez
que se desee resolver un problema diferente.
A las instrucciones anteriores le dimos el nombre de met_Euler.m.
Ejemplo:
Sea la siguiente ecuación diferencial:
Obtener el resultado por el método de Euler para y compararla gráficamente con la

solución exacta .
Solución:
Creamos en el editor la función que representará a la ecuación diferencial:
function dy=fcn(t,y)
dy=y/10;
Luego creamos el siguiente archivo script de nombre sol1_euler.m

t0=0; tf=5; y0=1000;
h=[1 0.5 0.1];
for k=1:length(h)
[t,y]=met_Euler(y0,t0,tf,h(k));
plot(t,y)
grid on
hold on
end
te=t0:0.1:tf;
ye=1000*exp(te/10);
plot(te,ye,'-r')
legend('h=1','h=0.5','h=0.1','Exacta')
hold off
156
y cuando ejecutamos dicho script obtendremos lo siguiente:
Método de Euler Modificado
La mejora del método de Euler es expresado como:
El código implementado en MATLAB para este método, el cual se encuentra en el CD, tiene por
nombre met_EulerMOD.m y se muestra a continuación.
% Metodo de Euler Modificado
function [t,y]=met_EulerMOD(y0,t0,tf,h)
t(1)=t0;
y(1)=y0;
k=1;
while t(k)<tf
t(k+1)=t0+k*h;
K1=h*fcn(t(k),y(k));
K2=h*fcn(t(k+1),y(k)+K1);
y(k+1)=y(k)+0.5*(K1+K2);
k=k+1;
end
Al igual que en el método de Euler, debemos definir la función fcn que representa a nuestra ecuación
diferencial.
157
Capítulo 10
Ejemplo:
Obtener la solución aproximada del siguiente problema, para h=0.01:
Y compararla gráficamente con la solución exacta:

Solución:
Creamos un script de nombre sol2_euler.m, cuyo contenido es:
t0=1.0610329; tf=3; y0=1.0610329;
h=0.01;
[t1,y1]=met_Euler(y0,t0,tf,h);
[t2,y2]=met_EulerMOD(y0,t0,tf,h);
te=t0:0.1:tf;
ye=100*(te.^-2).*sin(10./te);
plot(t1,y1,t2,y2,te,ye)
grid on
title('h=0.001','fontsize',14)
legend('Euler','Euler Modificado','Exacta')
El resultado de ejecución del script anterior es:
158
Ejercicio:
Utilizando el método de Euler, solucione numéricamente la siguiente ecuación:
De a , con h=0.25 y .
Método de Runge Kutta
Los métodos de Runge Kutta utilizan indirectamente el algoritmo de Taylor. En general, estos métodos
evalúan en más de un punto en la proximidad de en lugar de evaluar derivadas de ,
las cuales se necesitarían para el uso directo del algoritmo por series de Taylor.
La derivación de estos métodos se acompaña de la suposición de un algoritmo particular con ciertos
coeficientes indeterminados. Los valores de estos términos constantes se encuentran igualando la
fórmula de Runge Kutta de orden p al algoritmo de Taylor de orden . Las más comunes en aplicación
son las de orden 2,3 y 4; es decir, aquella que usa la ponderación de 2, 3 y 4 aproximaciones.
A continuación mostramos la forma de 4to orden:
Implementando una función de nombre sol_RK4.m en MATLAb que resuelva dicho algoritmo, el
código será:
% Metodo de Runge Kutta 4
function [t,y]=sol_RK4(f,y0,t0,tf,h)
% f: es una funcion referencial
fcn=f; t(1)=t0; y(1)=y0;
k=1;
while t(k)<tf
t(k+1)=t0+k*h;
K1=fcn(t(k),y(k));
K2=fcn(t(k)+h/2,y(k)+0.5*h*K1);
K3=fcn(t(k)+h/2,y(k)+0.5*h*K2);
K4=fcn(t(k+1)+h,y(k)+h*K3);
y(k+1)=y(k)+(h/6)*(K1+2*K2+2*K3+K4);
k=k+1;
end
159
Capítulo 10
Resolviendo el último ejemplo con este método y realizando las comparaciones con los métodos
anteriores. El script sol3_EDOS.m, tendrá las siguientes instrucciones:
t0=1.0610329; tf=3; y0=1.0610329;
h=0.01;
f=@(t,y) -200*(t^-3)*sin(10/t)-1000*(t^-4)*cos(10/t);
[t1,y1]=met_Euler(y0,t0,tf,h);
[t2,y2]=met_EulerMOD(y0,t0,tf,h);
[t3,y3]=met_RK4(f,y0,t0,tf,h);
te=t0:0.1:tf;
ye=100*(te.^-2).*sin(10./te);
plot(t1,y1,t2,y2,t3,y3,te,ye)
grid on
title('h=0.001','fontsize',14)
legend('Euler','Euler Modificado','RK4','Exacta')
Y la salida gráfica será el siguiente:
Funciones ode
Para resolver ecuaciones diferenciales ordinarias, MATLAB proporciona un conjunto de funciones que
nos permite realizar el cálculo de forma más eficiente, dos de estas funciones son: ode23 y ode45.
A continuación describimos los argumentos y luego presentaremos algunos ejemplos:
[t,y] = ode23(@funcion,tspam,CI)
[t,y] = ode45(@funcion,tspam,CI)
@funcion : Es la referencia de la función creada en el editor y que representa a la ecuación diferencial

ordinaria.
tspam : Vector de valores del dominio en que va a ser evaluada la función solución.
CI : Condición inicial
y : Función solución evaluada en los valores de tspam
t : Es un vector de los mismos elementos de tspam
160
Ambas funciones permiten obtener la solución aproximada de la ecuación diferencial .

Donde la primera sintaxis realiza el cálculo por el método de Runge Kutta de 2do y 3er orden,
mientras que el segundo (utilizado de forma estándar) realiza el cálculo por Método de Runge Kutta
de 4to y 5to orden
Ejemplo 1:
Resolver la siguiente ecuación diferencial:
dentro del intervalo [0,2], suponiendo que la condición inicial es:

Solución:
Primeramente creamos la función que representará a la ecuación diferencial, entocnes escribimos en
el editor lo siguiente:
function dy=funci(t,y)
dy=2*t.*(cos(t)).^2
Seguidamente realizamos un script para ejecutar y obtener la solución:

[t1,y1]=ode23(@funci,0:0.1:2,pi/4);
[t2,y2]=ode45(@funci,0:0.1:2,pi/4);
plot(t1,y1,t2,y2)
grid on
legend('RK23','RK45')
El resultado se muestra en la gráfica siguiente.
161
Capítulo 10
Ejemplo 2:
Durante un vuelo de prueba de un avión con un cierto motor turbohélice, el piloto de prueba ajustó
el nivel de potencia del motor a 40 000 Newtons, lo que hace que el avión de 20 000 Kg. alcance
una velocidad de crucero de 180 m/s. A continuación, las gargantas del motor se ajustan a un nivel
de potencia de 60 000 Newtons y el avión comienza a acelerar. Al aumentar la velocidad del avión,
el arrastre aerodinámico aumenta en proporción con el cuadrado de la velocidad respecto al aire.
Después de cierto tiempo, el avión alcanza una nueva velocidad de crucero en la que el empuje de
los motores es equilibrado por el arrastre. La ecuación diferencial que determina la aceleración del
avión es:
Donde:
Escribir un programa en MATLAB para determinar la nueva velocidad de crucero después del cambio
de nivel de potencia de motores, graficando la solución de la ecuación diferencial.
Solución:
Para este caso usamos la función ode23 para evaluar la ecuación diferencial. La solución de esta
ecuación nos dará valores de velocidad, que pueden servir para determinar valores de aceleración.
Realizando el script siguiente:
V0=180;
ts=240;
[t,V]=ode23(@funci2,0:0.1:ts,V0);
ac=3-0.000062*V.^2;
subplot 211
plot(t,V); title('Velocidad')
ylabel('m/s')
grid on;
subplot 212
plot(t,ac); title('aceleración')
ylabel('m/s^2')
xlabel('tiempo(s)')
grid on
La función funci2.m es:

function dv=funci2(t,v)
dv=3-0.000062*v.^2;
162
Y la salida grafica es:
Ejemplo 3:
Velocidad en medios con arrastre La ecuación diferencial que rige la velocidad v de un cuerpo de masa
m y área proyectada A que cae en un medio de densidad es:
(I)
El cuerpo adquiere su velocidad terminal de caída cuando no acelera más, es decir a derivada de a
velocidad es cero. De acuerdo a la ecuación anterior, la velocidad terminal teórica es:
(II)
Supóngase una moneda con y , que cae de un edificio, entonces

. La velocidad terminal según la expresión II es: . Resolver la ecuación
I por el método de Runge-Kutta y compara la velocidad terminal así hallada con la velocidad terminal
teórica.
Solución
Para resolver aplicamos la función met_RK4.m, de la siguiente manera
f=@(t,v) 10-v^2*(1*3.1416*10^-4)/(2*0.01);
[t,vel]=met_RK4(f,0,0,20,1)
plot(t,vel)
163
Capítulo 10
El resultado y la gráfica serán:

0 0
1.0000 9.3244
2.0000 16.3644
3.0000 20.6352
4.0000 22.8944
5.0000 24.0044
6.0000 24.5302
7.0000 24.7750
8.0000 24.8880
9.0000 24.9400
10.0000 24.9638
11.0000 24.9748
12.0000 24.9798
13.0000 24.9821
14.0000 24.9832 Se observa que la velocidad terminal hallada por
15.0000 24.9837
16.0000 24.9839
el método numérico es de 24.98m/s, la cual es
17.0000 24.9840
la misma teórica, lo que demuestra el poderío del
18.0000 24.9840 método de Runge-Kutta para la solución numérica
19.0000 24.9841 de ecuaciones diferenciales
20.0000 24.9841
Solución de Ecuaciones Diferenciales de Orden Superior
Para resolver ecuaciones diferenciales de orden superior (de orden mayor que 1) con condiciones
iniciales, se transforman en un sistema de ecuaciones diferenciales de orden 1 equivalente y se
resuelve éste. El número de ecuaciones diferenciales de primer orden del sistema es igual al orden
de la ecuación diferencial original.
Para el caso general, considere ahora la siguiente ecuación diferencial de orden :
y haciendo el siguiente cambio de variables:
Donde
164
Derivando los cambios de variables, tendremos el siguiente arreglo:
Luego utilizamos el solucionador ode45, para obtener el vector solución.

Ejemplo:
Se tiene la siguiente ecuación diferencial con condiciones iniciales:
Se desea resolver para con

Solución:
Dado que la ecuación diferencial es de orden 2. Debemos reducirla a un sistema de ecuaciones
diferenciales de primer orden, primero despejamos el término de segundo orden y empezamos la
reducción.
, donde:
Implementando la solución con el siguiente código para obtener los valores de función solución y
visualizar la gráfica.
[t,Xn]=ode45(@fun2,0:0.1:1,[1;1]);
y=Xn(:,1);
plot(t,y,'-b')
grid on
title('Solución de EDO de 2do Orden')
165
Capítulo 10
Donde la función de nombre funci.m está definida por el siguiente código.

function dX=fun2(t,X)
A=[0 1;5*t -2];

b=[0 exp(-2*t)];
dX=A*X+b
Ejemplo:
Un circuito tiene en serie una fem , un resistor de 2 , un inductor de 0.1 h y un
capacitor de 1/260 f. Si la corriente inicial y la carga inicial en el capacitor son ambas cero, calcular
la carga en el capacitor en cualquier instante de tiempo t.
Solución:
Recordamos que:
', además:
166
Reemplazando las expresiones para la corriente en la ecuación, tendremos la siguiente expresión:
Cambiando los valores de R, C y L y V:
Haciendo los cambios de variables, tenemos lo siguiente:
, donde:
Y realizando la ejecución del código siguiente, tendremos la siguiente salida.

[t,Xn]=ode45(@funCir,0:0.001:1,[0;0]);
y=Xn(:,1);
plot(t,y,'-b')
grid on
title('Solución de Circuito RLC')
Siendo la función funCir.m el siguiente código:

function dX=funCir(t,X)
A=[0 1;-2600 -20];

b=[0; 100*sin(60*t)];
dX=A*X+b;
Y la gráfica de la función resultado evaluada en el tiempo.
167
Impreso en los Talleres Gráficos de
Surquillo

719 9700 – 719 9701
Marzo 2012

Manual Matlab FIEE UNI PDF

Cargado por

Información del documento

Título original

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

Manual Matlab FIEE UNI PDF

Cargado por

Copyright:

Formatos disponibles

Colección G UÍAS P RÁCTICAS

© Derecho de autor reservado

© Derecho de edición, arte gráfico y diagramación reservados

Edición a cargo de:

(511) 719 - 9700

Primera edición: Marzo 2012 - 1000 ejemplares

Prohibida la reproducción parcial o total, por cualquier medio o método de este

Capítulo 2: Operaciones con Matrices y Vectores

Capítulo 3: Programación en Matlab

Capítulo 7: Resolución de Sistema de Ecuaciones Lineales

Capítulo 8: Solución de Ecuaciones No Lineales

Capítulo 10: Solución de Ecuaciones Diferenciales Ordinarias

La Ventana de Comandos (Command Window): Es el espacio principal de interacción entre el usuario

Las palabras reservadas son las siguientes:

char: Los caracteres deben estar entre apóstrofes.

Your variables are:

b Simple Precisión: single

La segunda forma es utilizando la función complex de la siguiente manera:

Tipo Función Rango de Valores

Ejemplos de ingreso de datos enteros:

Si se desea verificar si un dato es de tipo entero, utilizaremos la función isinteger:

Conversión de Tipo de Datos

La siguiente tabla muestra algunos valores especiales:

Funciones de Identificación de Tipo de Dato

Una cadena de texto se define como un ordenamiento o arreglo de caracteres UNICODE.

>> whos cadena

Las funciones class e ischar identifican si un dato es un arreglo de caracteres:

strncmp Determina si los n primeros caracteres de dos cadenas son idénticas.

La función isletter determina si un carácter es una letra.

Conversión de Valores Numéricos a Cadenas y Viceversa

A continuación, mostramos algunas formas de usar las funciones definidas:

>> enteros=[ 23 34 11];

>> num=[23.5 56 -0.34];

>> d=[123 37 98];

Tipos de formato de salida

>> x=[26/14 3 16.567246 4e-4];

>> format long

>> format rat

Entonces tenemos 2 representaciones de datos para ingresar:

>>mt = [23.7 6.7]

Matriz de Números Complejos

>> Cimaginario = imag(C)

>> Carg = angle(C)

>> Carg = angle(C)*180/pi

>> fila = [14 -6 10 18 43]

Operador paso (:)

Reconocimiento de los Elementos de una Matriz

>> a12 = A(1,2)

El programa inicia la asignación de la posición desde el primer elemento de la primera columna y

Las funciones anteriores tienen la siguiente sintaxis general para su generación:

>> Z3 = zeros([3 2])

Ya definida la matriz, podemos asignar a un dato un valor diferente a cero.

Matrices de elementos igual a la unidad:

Matriz de valores aleatorios entre 0 y 1:

>> x = rand % nuevamente un valor aleatorio

>> X = rand(5) % matriz de orden 5x5

>> X4 = 12+9*rand(1,5) % datos entre 12 y 21

Los números de datos incluyen a Val_ini y Val_fin.

Funciones Para el Análisis de Una Matriz

Un caso particular es cuando aplicamos la función a un vector, donde el resultado es numéricamente

>> q = [19 5 10 -3];

>> As2 = sum(A,2)

>> fila = [14 -6 10 18 43]