1
Ecuaciones Diferenciales En MATLAB-GUIDE
David Ruiz, Ariel Quishpe, Luis Quishpe , Milton Quimbita
Estudiantes de la ESPE-L
 • Modelado, simulación y prueba de prototipos
I. Resumen
Esta presentación en el simulador en MatLab se extiende
específicamente a la resolución de las Ecuaciones
Diferenciales Ordinarias, de tal manera que la interfaz sea
amigable con el estudiante o el usuario, en esta programación
además de resolver y arrojar el resultado en forma general se
le adiciono el ingresar las condiciones iniciales de tal manera
que también tengamos la respuesta parcial del problema,
teniendo en cuenta que la gráfica también es muy importante.
Para completar y hacer una herramienta completa y se
selección múltiple se ha añadido la transformada de Laplace y
su inversa adema de una graficadora aparte.
II. Abstract:
This presentation in the simulator in MatLab extends
specifically to the resolution of the ordinary differential
equations, in such a way that the interface is friendly with the
student or the user, in this programming besides to solve and
to throw the result in General form It is added to enter the
initial conditions in such a way that we also have the partial
answer of the problem, taking into account that the graph is
also very important. To complete and make a complete tool
and multiple selection has been added the Laplace transform
and its inverse adema of a plotter apart.
III. Desarrollo:
¿Qué es Matlab?
MATLAB es un lenguaje de alto desempeño diseñado para
realizar cálculos técnicos. MATLAB integra el cálculo, la
visualización y la programación en un ambiente fácil de
utilizar donde los problemas y las soluciones se expresan en
una notación matemática. MATLAB es un sistema interactivo
cuyo elemento básico de datos es el arreglo que no requiere de
dimensionamiento previo. Esto permite resolver muchos
problemas computacionales, específicamente aquellos que
involucren vectores y matrices, en un tiempo mucho menor al
requerido para escribir un programa en un lenguaje escalar no
interactivo tal como C o Fortran.
MATLAB se utiliza ampliamente en:
• Cálculos numéricos
• Desarrollo de algoritmos
• Análisis de datos, exploración y visualización
• Graficación de datos con fines científicos o de ingeniería
• Desarrollo de aplicaciones que requieran de una interfaz
gráfica de usuario (GUI, Graphical User Interface).
En el ámbito académico y de investigación, es la herramienta
estándar para los cursos introductorios y avanzados de
matemáticas, ingeniería e investigación. En la industria
MATLAB es la herramienta usada para el análisis,
investigación y desarrollo de nuevos productos tecnológicos.
La ventaja principal de MATLAB es el uso de familias de
comandos de áreas específicas llamadas toolboxes.
Lo más importante para los usuarios de MATLAB es que los
toolboxes le permiten aprender y aplicar la teoría. Los
toolboxes son grupos de comandos de MATLAB (archivos M)
que extienden el ambiente de MATLAB para resolver
problemas de áreas específicas de la ciencia e ingeniería. Por
ejemplo, existen toolboxes para las áreas de Procesamiento
Digital de Señales, Sistemas de Control, Redes Neuronales,
Lógica Difusa, Wavelets, etc.
I.1 La ventana de comando.
La ventana de comando es la ventana principal, con la cual el
usuario interactúa con MATLAB. Es la primera ventana que
se abre al ejecutar MATLAB. Se utiliza para correr los
comandos, correr el editor de archivos M (MEDIT, presente
en la barra de herramientas), ejecutar los toolboxes, etc.
La barra de herramientas proporciona un acceso fácil y rápido
a las operaciones más comunes. Al colocar el puntero del
ratón sobre algún botón durante un par de segundos,
 2

MATLAB despliega un tooltip, el cual da el nombre del botón Las expresiones utilizan los operadores aritméticos comunes.
ha seleccionado. Los operadores aritméticos son los mismos que en cualquier
I.2 Comandos principales lenguaje de programación y se sigue un orden de evaluación
similar al que se utiliza en los demás lenguajes de
En la Tabla I.2 se enlistan los comandos más comunes de la programación.
plataforma de simulación MATLAB. Dentro de estos
comandos se encuentran aquellos que realizan búsquedas, la En la Tabla II.1 se muestran los operadores aritméticos más
ayuda en línea, desplegar las variables presentes en el espacio comunes en MATLAB.
de trabajo, entre otras.
II.1 Expresiones en MATLAB
MATLAB como cualquier lenguaje de programación
proporciona expresiones matemáticas, pero a diferencia de la
mayoría de ellos, las expresiones matemáticas que maneja
involucran matrices completas.
Las expresiones se dividen en:
• Números
• Variables
• Operadores
• Funciones
II.1.1 Números MATLAB
Utiliza una notación decimal convencional con punto decimal
opcional y el signo menos para indicar números negativos. La II.1.4 Funciones MATLAB
notación científica utiliza la letra e para especificar el factor de Proporciona un gran número de funciones matemáticas
escala en potencias de 10. Los números imaginarios utilizan simples y avanzadas. La gran mayoría de estas funciones
ya sea la i o la j como sufijo. acepta argumentos complejos. Las funciones más comunes,
Todos los números se almacenan internamente usando el como sqrt y sin son parte del núcleo de MATLAB y están
formato long especificado por el estándar en punto flotante programadas en bajo nivel para hacerlas más eficientes y no es
IEEE. Los números en punto flotante tienen una precisión posible acceder a su código. El resto de las funciones está
finita aproximadamente de 16 dígitos decimales y un rango programada en archivos M y su código está disponible para
finito aproximadamente de 10-308 a 10-308. revisiones o modificaciones.
Muchas funciones especiales proporcionan o requieren valores
de constantes útiles. MATLAB incorpora constantes
matemáticas y cierta simbología, la cual se muestra en la
Tabla II.2.

II.1.2 Variables MATLAB

A diferencia de la mayoría de los lenguajes de programación
no requiere de ningún tipo de declaraciones de tipo de datos
(entero, punto flotante, complejos, etc) ni de
dimensionamiento. Cuando MATLAB encuentra una nueva
variable, automáticamente crea la variable y reserva la
cantidad de localidades de memoria necesarias. Si la variable
ya existía dentro del espacio de trabajo actual, simplemente
cambia el contenido, si se requiere, o de ser necesario agrega
más localidades de memoria a la variable para contener más
datos.
Ejemplo. Definición de variables.
» Num = 25
Esta variable crea una matriz de 1 x 1 llamada Num y
almacena el valor de 25.
MATLAB es case sensitive, es decir distingue entre
mayúsculas y minúsculas; es decir A y a no son la misma
variable.
II.1.3 Operadores
 3

II.1.5 MATLAB y la Estadística  Análisis de filtros digitales incluyendo respuesta en

Statistics Toolbox
Combina poderosos algoritmos estadísticos con interfaces
gráficas interactivas
Las Statistics Toolbox le da un rango ancho de herramientas
para realizar cálculos estadísticos. Proporciona una única
mezcla de facilidad gráfica de uso y programabilidad. Los
despliegues gráficos interactivos le permitieron aplicar
métodos estadísticos fácilmente y de forma consistente,
mientras el lenguaje de MATLAB le permite fácilmente crear
los acostumbrados métodos estadísticos y de análisis. Esta
combinación le da la libertad para acceder las funciones bajo-
niveladas directamente como funciones de probabilidad y
ANOVA de la línea del orden, o para usar las interfaces
interactivas para aprender y experimentar con el toolbox
construir-en visualización y herramientas del análisis.
frecuencia, retardo de grupo, retardo de fase.
 Implementación de filtros, tanto directo como usando
técnicas en el dominio de la frecuencia basadas en la
FFT.
 Diseño de filtros IIR, incluyendo Butterworth,
Chebyschev tipo I, Chebyshebv tipo II y elíptico.
 Diseño de filtros FIR mediante el algorítmo óptimo
de Parks-McClellan.
 Procesamiento de la transformada rápida de Fourier
FFT, incluyendo la transformación para potencias de
dos y su inversa, y transformada para no potencias de
dos.

El toolbox es el ambiente ideal no rutina para el montaje

ejemplar. Las capacidades primarias incluyen: el análisis de la
regresión y diagnóstica con selección inconstante, modelado
no lineal, probabilidad y estimación de parámetros, análisis de
sensibilidad que usa los generadores de número de azar,
control del proceso estadístico, y plan de experimentos.

Distribuciones de probabilidad. La Caja de Herramientas

Estadísticas ( Statistics TollBox ) apoya una colección de 20
distribuciones de probabilidad diferentes, incluso T, F, y
distribuciones del Chi-cuadrado, despliegues gráficos de
ataques, y se mantienen formas de calcular ataques mejores
todos los tipos de la distribución.

II.1.6 LIBRERIAS

Librería de Aplicaciones de MATLAB The MATLAB C Math Library

MATLAB tiene una gran colección de funciones para el
procesamiento de señal en el Signal Processing Toolbox. Este
incluye funciones para:
La MATLAB C Math Library proporciona al usuario la
capacidad computacional de MATLAB en una libreria en
formato objeto enlazable. El objetivo principal de la C Math
Library es soportar el desarrollo de aplicaciones 'stand alone'

utilizando MATLAB y su compilador. Puede ser utilizada
independientemente de MATLAB por programadores
avezados en lenguaje C que necesiten prestaciones
computacionales robustas y de alto rendimiento.
La MATLAB C Math Library proporciona una amplia gama
de funciones clásicas del programa MATLAB, proporcionadas
como librerías objeto, incluyendo básicamente las siguientes
categorías de funciones presentes en MATLAB y archivos M
compilados:
 Algebra lineal.
 Funciones matemáticas elementales y especializadas.
 Operadores lógicos y aritméticos.
 Matrices elementales y manipulación de vectores.
 Matrices especiales.
 Estadística básica y análisis de datos.
 Polinomios e interpolación.
 Gestión de cadenas de caracteres.
 Entradas y Salidas.
 Gestión de memoria y errores.
Utilización de MATLAB y de su compilador
Para construir una aplicación del tipo 'stand alone' que
incorpore código originalmente desarrollado como archivos M
de MATLAB, deberán de seguirse los pasos siguientes:
 Utilizar el compilador de MATLAB para convertir
archivos M en C mediante la utilización de la
instrucción mcc -e (la cual es externa a MATLAB).
 Compilar el código C fuente en código objeto
utilizando un compilador ANSI C.
 Enlazar el código resultante con la MATLAB C Math
Library y con cualquier tipo de archivos y programas
específicos que hayan sido previamente definidos por
el usuario.
Velocidad y Precisión
Los algoritmos utilizados en la MATLAB C Math Library han
sido desarrollados por un grupo de renombrados expertos en
programación algorítmica de funciones de tipo matemático
(algebra lineal y cálculo numérico). Las funciones de álgebra
lineal han sido obtenidas de las librerías mundialmente
reconocidas LINPACK y EISPACK. La MATLAB C Math
Library contiene más de 300 funciones numéricas, lógicas y
de utilidad. Todas estas funciones le permitirán operar en
datos de tipo escalar, vectorial o matricial con la misma
facilidad sintáctica.
La librería MATLAB C Math Library cumple con la
normativa estándar ANSI para compiladores C. Finalmente, la
librería trabajará con aquellos enlazadores que vienen
suministrad os con la mayoría de los compiladores ANSI C.
4
II.1.7 Limitaciones del código compilado
Ciertas instrucciones, como load y eval, no estan soportadas
por el compilador de MATLAB . Este no puede generar
código de los diagramas de bloques de SIMULINK. Los
toolboxes de MATLAB pueden incluir archivos MEX y otros
componentes que no son compilables.
SYMBOLIC MATH TOOLBOX
El Toolbox de Matemática Simbólica, añade a MATLAB la
capacidad de realizar cálculos simbólicos basados en MAPLE
V © soportando además (The Extended Symbolic Math
Toolbox) las librerías especializadas, y los programas
realizados para este último. Entre otros, los principales tipos
de operaciones soportados son los siguientes:
 Algebra simbólica: Derivación, integración y
simplificación de expresiones matemáticas.
 Algebra lineal exacta: Inversas, determinantes,
autovalores y formas canónicas de matrices
simbólicas.
 Aritmética de precisión variable: Evaluación de
expresiones matemáticas con diversos grados de
precisión.
 Resolución de ecuaciones: Resolución numérica y
simbólica de ecuaciones algebraicas y diferenciales.
 Funciones matemáticas especiales: Evaluación de la
mayoría de las funciones utilizadas en matemáticas
aplicadas.
II.1.8 Algunas de las áreas básicas que cubre este toolbox
para MATLAB son las siguientes:
 Cálculo de un extremo local (máximo o mínimo) de
una función real f(x), en general multivariable y no
lineal, sin imponer ninguna restricción o condición a
la solución. Como caso particular, se incluye una
rutina especial para problemas de mínimos cuadrados
no lineales.
 Cálculo de un extremo local (máximo o mínimo) de
una función real f(x), en general multivariable y no
lineal, condicionado a que la solución satisfaga

ciertas condiciones de desigualdad (g(x)<=0) y/o
igualdad (g(x)=0).
 Problemas de aproximación a un conjunto de
objetivos.
 Cálculo de soluciones de un sistema de ecuaciones
continuas y, en general, no lineales.
 Solución de problemas min y max.
 Programación lineal.
 Programación cuadrática.
 Problemas de mínimos cuadrados no negativos.
II.1.9 Algunas de las áreas de cobertura de la NAG
Foundation Toolbox son las siguientes:
 Ceros de polinomios
 Raíces de una o más ecuaciones de tipo trascendental.
 Suma de series..
 Ecuaciones diferenciales ordinarias.
 Ecuaciones diferenciales en derivadas parciales.
 Estadística no paramétrica.
 Análisis de series temporales.
 Rutinas de clasificación.
 Aproximación de funciones especiales.
 Aproximación de curvas y superficies.
 Maximización y minimización de funciones.
 Factorización de matrices.
 Valores y vectores propios.
 Resolución de ecuaciones lineales simultáneas.
 Ecuaciones lineales (LAPACK).
 Estadística básica.
 Análisis de correlación y regresiones.
 Métodos multivariantes.
 Generación de números aleatorios.
5
Como vemos la interfase de usuario de MATLAB no es muy
distinta a la de otras aplicaciones a las cuales estamos
acostumbrados, pero la verdadera diferencia consiste en la
utilidad que presta como aplicación para la investigación y el
desarrollo de modelos matemáticos y estadísticos los cuales
son tratados de forma interactiva, y con superposición de
ventanas en un entorno de fácil comprensión e interpretación
de los datos arrojados como resultados de los distintos rangos
de calculo que se pueden proporcionar a cada modelo de tal
forma que podemos hacer estudios de comportamiento y tratar
de determinar como se comportará una determinada variable a
través de una serie de experimentación en tiempo real.
Las ventanas de despliegue grafico son muy similares, en las
cuales el énfasis de la presentación se pone en la grafica
generada y no en el entorno de trabajo, es por esta razón que
puede parecer que el diseño de esta aplicación es escueto, pero
debemos recordar que como todo este tipo de aplicaciones su
desarrollo está orientado al logro de un objetivo especifico
como es el resolver modelos matemáticos.
III. Operaciones con reducción a variable separable
: Una ecuación diferencial ordinaria de primer orden de la
forma:
𝑦´ = 𝐹 (𝑥, 𝑦 )
se dice de Variables Separables si es posible factorizar F (x, y)
en la forma:
𝐹 (𝑥, 𝑦) = 𝑓 ( 𝑥 ) · 𝑔 ( 𝑦 )
Una EDO de variables separables puede resolverse usando la
siguiente estrategia:
- Procedimiento: Variables Separables
- Entrada: Una EDO en la forma Y´ = F (x, y)
- Salida: La solución de la ED.
Paso I: Factorizar el segundo miembro.
Factorizar F (x, y) = f ( x ) · g ( y ),si tal factorización no es
posible, se concluye que la ED no es de variables separables y
el procedimiento no continuo.
Paso II: Separar las variables Hacer álgebra para poner
variables diferentes en lados diferentes:
y´ = F (x, y)
y´ = f (x) ∗ g y)
𝑑𝑦
= 𝑓(𝑥) ∗ 𝑔(𝑥)
𝑑𝑥
1 𝑑𝑦
= 𝑓(𝑥)
𝑔(𝑥) 𝑑𝑥
 6

Paso III: Integrar Integrando la expresión anterior con if nargout

respecto a x obtenemos: [varargout{1:nargout}] =
gui_mainfcn(gui_State, varargin{:});
1 𝑑𝑦 else
∫ 𝑑𝑥 = ∫ 𝑓(𝑥) 𝑑𝑥
𝑔(𝑥) 𝑑𝑥 gui_mainfcn(gui_State, varargin{:});
end
varargout{1} = handles.output;
o simplemente: set(handles.selec,'visible','on')
set(handles.ilaplace,'visible','on')
1 set(handles.ecuaciones,'visible','on')
∫ 𝑑𝑦 = ∫ 𝑓(𝑥) 𝑑𝑥 + 𝑐
𝑔(𝑥) set(handles.graficas,'visible','on')
set(handles.laplace,'visible','on')
Paso IV: Despejar y Opcional
set(handles.y3,'visible','off')
Debido a que y representa la función incógnita a determinar, set(handles.y2,'visible','off')
lo ideal es determinarla por completo, es decir tener como set(handles.y1,'visible','off')
solución una expresión de la forma: set(handles.y,'visible','off')
set(handles.x,'visible','off')
Y = Expresión en x set(handles.yiv,'visible','off')
En caso que este despeje sea posible, se dice que la solución set(handles.yiii,'visible','off')
set(handles.yii,'visible','off')
está dada en forma explícita, en caso contrario (cuando no fue
set(handles.yi,'visible','off')
posible despejar y) se dice que la solución está dada en forma set(handles.y0,'visible','off')
implícita. set(handles.uno,'visible','off')
set(handles.dos,'visible','off')
set(handles.tres,'visible','off')
Ejemplo: Resolver la Ecuacion Diderencial set(handles.cuatro,'visible','off')
𝒅𝒚 𝟐𝒙 set(handles.igual,'visible','off')
=− set(handles.orden,'visible','off')
𝒅𝒙 𝒚 set(handles.ordened,'visible','off')
Primero revisamos si la ED es de variables separables: set(handles.c,'visible','off')
set(handles.ci,'visible','off')
𝑑𝑦 2𝑥 1 set(handles.ci1,'visible','off')
=− = (−2𝑥) ( ) = 𝑓(𝑥) ∗ 𝑔(𝑥)
𝑑𝑥 𝑦 𝑦 set(handles.ci2,'visible','off')
set(handles.ci3,'visible','off')
Separando las variables:
set(handles.ci4,'visible','off')
𝑦 𝑑𝑦 = −2𝑥 𝑑𝑥 set(handles.cci1,'visible','off')
set(handles.cci2,'visible','off')
Integrado tenemos:
set(handles.cci3,'visible','off')
set(handles.cci4,'visible','off')
∫ 𝑦 𝑑𝑦 = ∫ −2𝑥 𝑑𝑥 set(handles.a,'visible','off')
set(handles.b,'visible','off')
1 2 set(handles.ab,'visible','off')
𝑦 = −𝑥 2 + 𝑐
2 set(handles.res,'visible','off')
set(handles.resultado,'visible','off')
set(handles.boton1,'visible','off')
1
La expresión 𝑦 2 = −𝑥 2 + 𝑐 presentauna familia de set(handles.boton2,'visible','off')
2
soluciones: una solucion para cada constante c. set(handles.boton3,'visible','off')
set(handles.boton4,'visible','off')
Usando Nuestra Interfaz, exiviremos nuestro codigo de set(handles.res2,'visible','off')
programación: set(handles.resultado2,'visible','off')
set(handles.lap,'visible','off')
function varargout = deber(varargin)
set(handles.lapl,'visible','off')
gui_Singleton = 1;
set(handles.tdlp,'visible','off')
gui_State = struct('gui_Name',
set(handles.tidlp,'visible','off')
mfilename, ...
set(handles.graf,'visible','off')
'gui_Singleton',
set(handles.ed,'visible','off')
gui_Singleton, ...
set(handles.atras,'visible','off')
'gui_OpeningFcn',
set(handles.plot,'visible','off')
@deber_OpeningFcn, ...
set(handles.seno,'visible','off')
'gui_OutputFcn',
set(handles.cos,'visible','off')
@deber_OutputFcn, ...
set(handles.tan,'visible','off')
'gui_LayoutFcn', [] , ...
set(handles.sec,'visible','off')
'gui_Callback', []);
set(handles.grafec,'visible','off')
if nargin && ischar(varargin{1})
set(handles.int,'visible','off')
gui_State.gui_Callback =
set(handles.yigual,'visible','off')
str2func(varargin{1});
set(handles.borrar,'visible','off')
end
set(handles.flap,'visible','off')

set(handles.filap,'visible','off')
set(handles.graficax,'visible','off')
set(handles.axes2,'visible','off')
% --- Executes on button press in laplace.
function laplace_Callback(hObject, eventdata,
handles)
% hObject handle to laplace (see GCBO)
% eventdata reserved - to be defined in a
future version of MATLAB
% handles structure with handles and user
data (see GUIDATA)
set(handles.laplace,'value',0)
set(handles.resultado2,'string',' ')
set(handles.lapl,'string',' ')
set(handles.selec,'visible','off')
set(handles.ilaplace,'visible','off')
set(handles.ecuaciones,'visible','off')
set(handles.graficas,'visible','off')
set(handles.laplace,'visible','off')
set(handles.y3,'visible','off')
set(handles.graficax,'visible','off')
set(handles.axes2,'visible','off')
set(handles.y2,'visible','off')
set(handles.y1,'visible','off')
set(handles.y,'visible','off')
set(handles.x,'visible','off')
set(handles.yiv,'visible','off')
set(handles.yiii,'visible','off')
set(handles.yii,'visible','off')
set(handles.yi,'visible','off')
set(handles.y0,'visible','off')
set(handles.uno,'visible','off')
set(handles.dos,'visible','off')
set(handles.tres,'visible','off')
set(handles.cuatro,'visible','off')
set(handles.igual,'visible','off')
set(handles.orden,'visible','off')
set(handles.ordened,'visible','off')
set(handles.c,'visible','off')
set(handles.ci,'visible','off')
set(handles.ci1,'visible','off')
set(handles.ci2,'visible','off')
set(handles.ci3,'visible','off')
set(handles.ci4,'visible','off')
set(handles.cci1,'visible','off')
set(handles.cci2,'visible','off')
set(handles.cci3,'visible','off')
set(handles.cci4,'visible','off')
set(handles.a,'visible','off')
set(handles.b,'visible','off')
set(handles.ab,'visible','off')
set(handles.res,'visible','off')
set(handles.resultado,'visible','off')
set(handles.res2,'visible','on')
set(handles.resultado2,'visible','on')
set(handles.boton1,'visible','off')
set(handles.boton2,'visible','on')
set(handles.boton3,'visible','off')
set(handles.boton4,'visible','off')
set(handles.lap,'visible','on')
set(handles.lapl,'visible','on')
set(handles.ed,'visible','off')
set(handles.tidlp,'visible','off')
set(handles.tdlp,'visible','on')
set(handles.graf,'visible','off')
set(handles.atras,'visible','on')
7
set(handles.borrar,'visible','on')
set(handles.flap,'visible','on')
% Hint: get(hObject,'Value') returns toggle
state of laplace
% --- Executes on button press in ilaplace.
function ilaplace_Callback(hObject, eventdata,
handles)
set(handles.ilaplace,'value',0)
set(handles.resultado2,'string',' ')
set(handles.lapl,'string',' ')
set(handles.selec,'visible','off')
set(handles.ilaplace,'visible','off')
set(handles.ecuaciones,'visible','off')
set(handles.graficax,'visible','off')
set(handles.axes2,'visible','off')
set(handles.graficas,'visible','off')
set(handles.laplace,'visible','off')
set(handles.y3,'visible','off')
set(handles.y2,'visible','off')
set(handles.y1,'visible','off')
set(handles.y,'visible','off')
set(handles.x,'visible','off')
set(handles.yiv,'visible','off')
set(handles.yiii,'visible','off')
set(handles.yii,'visible','off')
set(handles.yi,'visible','off')
set(handles.y0,'visible','off')
set(handles.uno,'visible','off')
set(handles.dos,'visible','off')
set(handles.tres,'visible','off')
set(handles.cuatro,'visible','off')
set(handles.igual,'visible','off')
set(handles.orden,'visible','off')
set(handles.ordened,'visible','off')
set(handles.c,'visible','off')
set(handles.ci,'visible','off')
set(handles.ci1,'visible','off')
set(handles.ci2,'visible','off')
set(handles.ci3,'visible','off')
set(handles.ci4,'visible','off')
set(handles.cci1,'visible','off')
set(handles.cci2,'visible','off')
set(handles.cci3,'visible','off')
set(handles.cci4,'visible','off')
set(handles.a,'visible','off')
set(handles.b,'visible','off')
set(handles.ab,'visible','off')
set(handles.res,'visible','off')
set(handles.resultado,'visible','off')
set(handles.res2,'visible','on')
set(handles.resultado2,'visible','on')
set(handles.boton1,'visible','off')
set(handles.boton2,'visible','off')
set(handles.boton3,'visible','on')
set(handles.boton4,'visible','off')
set(handles.lap,'visible','on')
set(handles.lapl,'visible','on')
set(handles.ed,'visible','off')
set(handles.tdlp,'visible','off')
set(handles.graf,'visible','off')
set(handles.tidlp,'visible','on')
set(handles.atras,'visible','on')
set(handles.borrar,'visible','on')

set(handles.filap,'visible','on')
% Hint: get(hObject,'Value') returns toggle
state of ilaplace
% --- Executes on button press in ecuaciones.
function ecuaciones_Callback(hObject,
eventdata, handles)
set(handles.ecuaciones,'value',0)
set(handles.atras,'visible','on')
set(handles.resultado2,'string',' ')
set(handles.lapl,'string',' ')
set(handles.ordened,'visible','on')
set(handles.orden,'visible','on')
set(handles.selec,'visible','off')
set(handles.graficax,'visible','on')
set(handles.axes2,'visible','on')
set(handles.ilaplace,'visible','off')
set(handles.ecuaciones,'visible','off')
set(handles.graficas,'visible','off')
set(handles.laplace,'visible','off')
set(handles.tdlp,'visible','off')
set(handles.tidlp,'visible','off')
set(handles.graf,'visible','off')
set(handles.ed,'visible','on')
set(handles.borrar,'visible','on')
% Hint: get(hObject,'Value') returns toggle
state of ecuaciones
% --- Executes on button press in graficas.
function graficas_Callback(hObject, eventdata,
handles)
set(handles.graficas,'value',0)
set(handles.selec,'visible','off')
set(handles.ilaplace,'visible','off')
set(handles.ecuaciones,'visible','off')
set(handles.graficas,'visible','off')
set(handles.laplace,'visible','off')
set(handles.y3,'visible','off')
set(handles.graficax,'visible','off')
set(handles.axes2,'visible','off')
set(handles.y2,'visible','off')
set(handles.y1,'visible','off')
set(handles.y,'visible','off')
set(handles.x,'visible','off')
set(handles.yiv,'visible','off')
set(handles.yiii,'visible','off')
set(handles.yii,'visible','off')
set(handles.yi,'visible','off')
set(handles.y0,'visible','off')
set(handles.uno,'visible','off')
set(handles.dos,'visible','off')
set(handles.tres,'visible','off')
set(handles.cuatro,'visible','off')
set(handles.igual,'visible','off')
set(handles.orden,'visible','off')
set(handles.ordened,'visible','off')
set(handles.c,'visible','off')
set(handles.ci,'visible','off')
set(handles.ci1,'visible','off')
set(handles.ci2,'visible','off')
set(handles.ci3,'visible','off')
set(handles.ci4,'visible','off')
set(handles.cci1,'visible','off')
8
set(handles.cci2,'visible','off')
set(handles.cci3,'visible','off')
set(handles.cci4,'visible','off')
set(handles.a,'visible','off')
set(handles.b,'visible','off')
set(handles.ab,'visible','off')
set(handles.res,'visible','off')
set(handles.resultado,'visible','off')
set(handles.res2,'visible','off')
set(handles.resultado2,'visible','off')
set(handles.boton1,'visible','off')
set(handles.boton2,'visible','off')
set(handles.boton3,'visible','off')
set(handles.boton4,'visible','off')
set(handles.lap,'visible','off')
set(handles.lapl,'visible','off')
set(handles.ed,'visible','off')
set(handles.tidlp,'visible','off')
set(handles.graf,'visible','on')
set(handles.tdlp,'visible','off')
set(handles.atras,'visible','on')
set(handles.plot,'visible','on')
set(handles.seno,'visible','on')
set(handles.cos,'visible','on')
set(handles.tan,'visible','on')
set(handles.sec,'visible','on')
set(handles.grafec,'visible','on')
function edit1_Callback(hObject, eventdata,
handles)
function edit1_CreateFcn(hObject, eventdata,
handles)
% See ISPC and COMPUTER.
if ispc &&
isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end
function uno_Callback(hObject, eventdata,
handles)
function uno_CreateFcn(hObject, eventdata,
handles)
if ispc &&
isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end
function y3_Callback(hObject, eventdata,
handles)
function y3_CreateFcn(hObject, eventdata,
handles)
% hObject handle to y3 (see GCBO)
% eventdata reserved - to be defined in a
future version of MATLAB
% handles empty - handles not created until
after all CreateFcns called
% Hint: edit controls usually have a white
background on Windows.

% See ISPC and COMPUTER.
if ispc &&
isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end
function dos_Callback(hObject, eventdata,
handles)
function dos_CreateFcn(hObject, eventdata,
handles)
if ispc &&
isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end
function y2_Callback(hObject, eventdata,
handles)
function y2_CreateFcn(hObject, eventdata,
handles)
if ispc &&
isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end
function y1_Callback(hObject, eventdata,
handles)
function y1_CreateFcn(hObject, eventdata,
handles)
if ispc &&
isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end
function y_Callback(hObject, eventdata,
handles)
function y_CreateFcn(hObject, eventdata,
handles)
if ispc &&
isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end
function x_Callback(hObject, eventdata,
handles)
function x_CreateFcn(hObject, eventdata,
handles)
if ispc &&
isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end
9
function tres_Callback(hObject, eventdata,
handles)
function tres_CreateFcn(hObject, eventdata,
handles)
if ispc &&
isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end
function cuatro_Callback(hObject, eventdata,
handles)
function cuatro_CreateFcn(hObject, eventdata,
handles)
if ispc &&
isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end
function edit13_Callback(hObject, eventdata,
handles)
function edit13_CreateFcn(hObject, eventdata,
handles)
if ispc &&
isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end
function edit14_Callback(hObject, eventdata,
handles)
if ispc &&
isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end
function edit15_Callback(hObject, eventdata,
handles)
function edit15_CreateFcn(hObject,
if ispc &&
isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end
function edit16_Callback(hObject, eventdata,
handles)
function edit16_CreateFcn(hObject, eventdata,
handles)
isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))

set(hObject,'BackgroundColor','white');
end
function edit17_Callback(hObject, eventdata,
handles)
function edit17_CreateFcn(hObject, eventdata,
handles)
if ispc &&
isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end
function edit18_Callback(hObject, eventdata,
handles)
function edit18_CreateFcn(hObject, eventdata,
handles)
if ispc &&
isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end
function edit19_Callback(hObject, eventdata,
handles)
function edit19_CreateFcn(hObject, eventdata,
handles)
if ispc &&
isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end
function edit20_Callback(hObject, eventdata,
handles)
function edit20_CreateFcn(hObject, eventdata,
handles)
if ispc &&
isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end
function edit21_Callback(hObject, eventdata,
handles)
function edit21_CreateFcn(hObject, eventdata,
handles)
if ispc &&
isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end
function ordened_Callback(hObject, eventdata,
handles)
10
opcion=str2double(get(handles.ordened,'string'
)); % orden de la ecuacion
switch opcion
case 1 % orden=1
set(handles.selec,'visible','off')
set(handles.ilaplace,'visible','off')
set(handles.ecuaciones,'visible','off')
set(handles.graficas,'visible','off')
set(handles.laplace,'visible','off')
set(handles.y3,'visible','off')
set(handles.y2,'visible','off')
set(handles.y1,'visible','off')
set(handles.y,'visible','on')
set(handles.x,'visible','on')
set(handles.yiv,'visible','off')
set(handles.yiii,'visible','off')
set(handles.yii,'visible','off')
set(handles.yi,'visible','off')
set(handles.y0,'visible','on')
set(handles.uno,'visible','off')
set(handles.dos,'visible','off')
set(handles.tres,'visible','off')
set(handles.cuatro,'visible','on')
set(handles.igual,'visible','on')
set(handles.ci,'visible','on')
set(handles.ci,'visible','on')
set(handles.ci1,'visible','on')
set(handles.ci2,'visible','off')
set(handles.ci3,'visible','off')
set(handles.ci4,'visible','off')
set(handles.cci1,'visible','on')
set(handles.cci2,'visible','off')
set(handles.cci3,'visible','off')
set(handles.cci4,'visible','off')
set(handles.a,'visible','on')
set(handles.b,'visible','off')
set(handles.ab,'visible','off')
set(handles.res,'visible','on')
set(handles.resultado,'visible','on')
set(handles.boton1,'visible','on')
set(handles.boton2,'visible','off')
set(handles.boton3,'visible','off')
set(handles.boton4,'visible','off')
case 2 %orden= 2
set(handles.selec,'visible','off')
set(handles.ilaplace,'visible','off')
set(handles.ecuaciones,'visible','off')
set(handles.graficas,'visible','off')
set(handles.laplace,'visible','off')
set(handles.y3,'visible','off')
set(handles.y2,'visible','off')
set(handles.y1,'visible','on')
set(handles.y,'visible','on')
set(handles.x,'visible','on')
set(handles.yiv,'visible','off')
set(handles.yiii,'visible','off')
set(handles.yii,'visible','off')
set(handles.yi,'visible','on')
set(handles.y0,'visible','on')
set(handles.uno,'visible','off')
set(handles.dos,'visible','off')
set(handles.tres,'visible','on')
set(handles.cuatro,'visible','on')
set(handles.igual,'visible','on')
set(handles.c,'visible','on')
set(handles.ci,'visible','on')

set(handles.ci1,'visible','on')
set(handles.ci2,'visible','on')
set(handles.ci3,'visible','off')
set(handles.ci4,'visible','off')
set(handles.cci1,'visible','on')
set(handles.cci2,'visible','on')
set(handles.cci3,'visible','off')
set(handles.cci4,'visible','off')
set(handles.a,'visible','off')
set(handles.b,'visible','on')
set(handles.ab,'visible','off')
set(handles.res,'visible','on')
set(handles.resultado,'visible','on')
set(handles.boton1,'visible','on')
set(handles.boton2,'visible','off')
set(handles.boton3,'visible','off')
set(handles.boton4,'visible','off')
case 3
set(handles.selec,'visible','off')
set(handles.ilaplace,'visible','off')
set(handles.ecuaciones,'visible','off')
set(handles.graficas,'visible','off')
set(handles.laplace,'visible','off')
set(handles.y3,'visible','off')
set(handles.y2,'visible','on')
set(handles.y1,'visible','on')
set(handles.y,'visible','on')
set(handles.x,'visible','on')
set(handles.yiv,'visible','off')
set(handles.yiii,'visible','off')
set(handles.yii,'visible','on')
set(handles.yi,'visible','on')
set(handles.y0,'visible','on')
set(handles.uno,'visible','off')
set(handles.dos,'visible','on')
set(handles.tres,'visible','on')
set(handles.cuatro,'visible','on')
set(handles.igual,'visible','on')
set(handles.c,'visible','on')
set(handles.ci,'visible','on')
set(handles.ci1,'visible','on')
set(handles.ci2,'visible','on')
set(handles.ci3,'visible','on')
set(handles.ci4,'visible','off')
set(handles.cci1,'visible','on')
set(handles.cci2,'visible','on')
set(handles.cci3,'visible','on')
set(handles.cci4,'visible','off')
set(handles.a,'visible','off')
set(handles.b,'visible','off')
set(handles.ab,'visible','on')
set(handles.res,'visible','on')
set(handles.resultado,'visible','on')
set(handles.boton1,'visible','on')
set(handles.boton2,'visible','off')
set(handles.boton3,'visible','off')
set(handles.boton4,'visible','off')
case 4
set(handles.selec,'visible','off')
set(handles.ilaplace,'visible','off')
set(handles.ecuaciones,'visible','off')
set(handles.graficas,'visible','off')
set(handles.laplace,'visible','off')
set(handles.y3,'visible','on')
set(handles.y2,'visible','on')
set(handles.y1,'visible','on')
11
set(handles.y,'visible','on')
set(handles.x,'visible','on')
set(handles.yiv,'visible','on')
set(handles.yiii,'visible','on')
set(handles.yii,'visible','on')
set(handles.yi,'visible','on')
set(handles.y0,'visible','on')
set(handles.uno,'visible','on')
set(handles.dos,'visible','on')
set(handles.tres,'visible','on')
set(handles.cuatro,'visible','on')
set(handles.igual,'visible','on')
set(handles.ci,'visible','on')
set(handles.ci1,'visible','on')
set(handles.ci2,'visible','on')
set(handles.ci3,'visible','on')
set(handles.ci4,'visible','on')
set(handles.cci1,'visible','on')
set(handles.cci2,'visible','on')
set(handles.cci3,'visible','on')
set(handles.cci4,'visible','on')
set(handles.a,'visible','off')
set(handles.b,'visible','off')
set(handles.ab,'visible','off')
set(handles.res,'visible','on')
set(handles.resultado,'visible','on')
set(handles.boton1,'visible','on')
set(handles.boton2,'visible','off')
set(handles.boton3,'visible','off')
set(handles.boton4,'visible','off')
end
function ordened_CreateFcn(hObject, eventdata,
handles)
if ispc &&
isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end
function cci1_Callback(hObject, eventdata,
handles)
function cci1_CreateFcn(hObject, eventdata,
handles)
if ispc &&
isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end
function cci2_Callback(hObject, eventdata,
handles)
function cci2_CreateFcn(hObject, eventdata,
handles)
if ispc &&
isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end
 12

function cci3_Callback(hObject, eventdata, E=Y2+ct*Y1+at*Y-btt;

handles) Y=solve(E,Y)
function cci3_CreateFcn(hObject, eventdata, y=ilaplace(Y,s,t)
handles) set(handles.resultado,'String',char(y))
if ispc &&
isequal(get(hObject,'BackgroundColor'), case 3 %orden=3
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white'); syms t s Y;
end at=get(handles.y,'string');
bt=get(handles.x,'string');
ct=get(handles.y1,'string');
dt=get(handles.y2,'string');
function cci4_Callback(hObject, eventdata, t0=get(handles.cci1,'string');
handles) t1=get(handles.cci2,'string');
function cci4_CreateFcn(hObject, eventdata, t2=get(handles.cci3,'string');
handles) btt=laplace(bt,t,s);
if ispc && d3y=diff(sym('Y(t)'),3);
isequal(get(hObject,'BackgroundColor'), Y3=laplace(d3y,t,s)
get(0,'defaultUicontrolBackgroundColor')) d2y=diff(sym('Y(t)'),2);
set(hObject,'BackgroundColor','white'); Y2=laplace(d2y,t,s)
end d1y=diff(sym('Y(t)'),1);
Y1=laplace(d1y,t,s)
Y1=s*Y-t0;
% --- Executes on button press in boton1. Y2=s*Y1-t1;
function boton1_Callback(hObject, eventdata, Y3=s*Y2-t2;
handles) E=Y3+dt*Y2+ct*Y1+at*Y-btt;
% hObject handle to boton1 (see GCBO) Y=solve(E,Y)
% eventdata reserved - to be defined in a y=ilaplace(Y,s,t)
future version of MATLAB set(handles.resultado,'String',char(y))
% handles structure with handles and user
data (see GUIDATA) case 4
%Declaramos las variables
opcion=str2double(get(handles.ordened,'string' syms t s Y;
)); % orden de la ecuacion at=get(handles.y,'string');
switch opcion bt=get(handles.x,'string');
case 1 %orden de la ecuacion=1 ct=get(handles.y1,'string');
dt=get(handles.y2,'string');
syms t s Y; et=get(handles.y3,'string');
at=get(handles.y,'string'); t0=get(handles.cci1,'string');
bt=get(handles.x,'string'); t1=get(handles.cci2,'string');
t0=get(handles.cci1,'string'); t2=get(handles.cci3,'string');
btt=laplace(bt,t,s); t3=get(handles.cci4,'string');
btt=laplace(bt,t,s);
d1y=diff(sym('Y(t)'),1); d4y=diff(sym('Y(t)'),4);
Y1=laplace(d1y,t,s) Y4=laplace(d4y,t,s)
Y1=s*Y-t0; d3y=diff(sym('Y(t)'),3);
E=Y1+at*Y-btt; Y3=laplace(d3y,t,s)
Y=solve(E,Y) d2y=diff(sym('Y(t)'),2);
y=ilaplace(Y,s,t) Y2=laplace(d2y,t,s)
set(handles.resultado,'String',char(y)) d1y=diff(sym('Y(t)'),1);
Y1=laplace(d1y,t,s)
Y1=s*Y-t0;
case 2 %orden= 2 Y2=s*Y1-t1;
Y3=s*Y2-t2;
syms t s Y; Y4=s*Y3-t3;
at=get(handles.y,'string'); E=Y4-et*Y3+dt*Y2+ct*Y1+at*Y-btt;
bt=get(handles.x,'string'); Y=solve(E,Y)
ct=get(handles.y1,'string'); y=ilaplace(Y,s,t)
t0=get(handles.cci1,'string'); set(handles.resultado,'String',char(y))
t1=get(handles.cci2,'string');
btt=laplace(bt,t,s); end
d2y=diff(sym('Y(t)'),2);
Y2=laplace(d2y,t,s) function resultado_Callback(hObject,
d1y=diff(sym('Y(t)'),1); eventdata, handles)
Y1=laplace(d1y,t,s) function resultado_CreateFcn(hObject,
Y1=s*Y-t0; eventdata, handles)
Y2=s*Y1-t1;
 13

if ispc && function pushbutton5_Callback(hObject,

isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end
% --- Executes on button press in boton2.
function boton2_Callback(hObject, eventdata,
handles)
%Ingreso la funcion
f=get(handles.lapl,'string')
syms s
%Aplicar la TL
sol=laplace(f,s)
set(handles.resultado2,'String',char(sol))
function boton3_Callback(hObject, eventdata,
handles)
syms t
%Ingresar la función
f=get(handles.lapl,'string')
%til
sol=ilaplace(f,t)
set(handles.resultado2,'string',char(sol))
% --- Executes on button press in boton4.
function boton4_Callback(hObject, eventdata,
handles)
% hObject handle to boton4 (see GCBO)
% eventdata reserved - to be defined in a
future version of MATLAB
% handles structure with handles and user
data (see GUIDATA)
x=0:0.005:10;
w=get(handles.int,'string');
y=eval(w);
plot(x,y); grid
function lapl_Callback(hObject, eventdata,
handles)
function lapl_CreateFcn(hObject, eventdata,
handles)
if ispc &&
isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end
function resultado2_Callback(hObject,
eventdata, handles)
function resultado2_CreateFcn(hObject,
eventdata, handles)
if ispc &&
isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end
% --- Executes on button press in pushbutton5.
eventdata, handles)
% hObject handle to pushbutton5 (see GCBO)
% eventdata reserved - to be defined in a
future version of MATLAB
% handles structure with handles and user
data (see GUIDATA)
% --- Executes on button press in atras.
function atras_Callback(hObject, eventdata,
handles)
% hObject handle to atras (see GCBO)
% eventdata reserved - to be defined in a
future version of MATLAB
% handles structure with handles and user
data (see GUIDATA)
set(handles.selec,'visible','on')
set(handles.ilaplace,'visible','on')
set(handles.ecuaciones,'visible','on')
set(handles.graficas,'visible','on')
set(handles.laplace,'visible','on')
set(handles.y3,'visible','off')
set(handles.y2,'visible','off')
set(handles.y1,'visible','off')
set(handles.y,'visible','off')
set(handles.x,'visible','off')
set(handles.yiv,'visible','off')
set(handles.yiii,'visible','off')
set(handles.yii,'visible','off')
set(handles.yi,'visible','off')
set(handles.y0,'visible','off')
set(handles.uno,'visible','off')
set(handles.dos,'visible','off')
set(handles.tres,'visible','off')
set(handles.cuatro,'visible','off')
set(handles.igual,'visible','off')
set(handles.orden,'visible','off')
set(handles.ordened,'visible','off')
set(handles.c,'visible','off')
set(handles.ci,'visible','off')
set(handles.ci1,'visible','off')
set(handles.ci2,'visible','off')
set(handles.ci3,'visible','off')
set(handles.ci4,'visible','off')
set(handles.cci1,'visible','off')
set(handles.cci2,'visible','off')
set(handles.cci3,'visible','off')
set(handles.cci4,'visible','off')
set(handles.a,'visible','off')
set(handles.b,'visible','off')
set(handles.ab,'visible','off')
set(handles.res,'visible','off')
set(handles.resultado,'visible','off')
set(handles.boton1,'visible','off')
set(handles.boton2,'visible','off')
set(handles.boton3,'visible','off')
set(handles.boton4,'visible','off')
set(handles.res2,'visible','off')
set(handles.resultado2,'visible','off')
set(handles.lap,'visible','off')
set(handles.lapl,'visible','off')
set(handles.tdlp,'visible','off')
set(handles.tidlp,'visible','off')
set(handles.graf,'visible','off')
set(handles.ed,'visible','off')
set(handles.atras,'visible','on')

set(handles.seno,'visible','off')
set(handles.cos,'visible','off')
set(handles.grafec,'visible','off')
set(handles.int,'visible','off')
set(handles.tan,'visible','off')
set(handles.sec,'visible','off')
set(handles.atras,'visible','off')
set(handles.yigual,'visible','off')
set(handles.ordened,'string',' ')
set(handles.lapl,'string',' ')
set(handles.y3,'string',' ')
set(handles.y2,'string',' ')
set(handles.y1,'string',' ')
set(handles.y,'string',' ')
set(handles.x,'string',' ')
set(handles.cci1,'string',' ')
set(handles.cci2,'string',' ')
set(handles.cci3,'string',' ')
set(handles.cci4,'string',' ')
set(handles.resultado,'string',' ')
set(handles.yigual,'visible','off')
set(handles.flap,'visible','off')
set(handles.graficax,'visible','off')
set(handles.filap,'visible','off')
set(handles.borrar,'visible','off')
set(handles.axes2,'visible','off')
x=0
y=x
plot(x,y)
set(handles.plot,'visible','off')
% --- Executes on button press in salir.
function salir_Callback(hObject, eventdata,
handles)
% hObject handle to salir (see GCBO)
% eventdata reserved - to be defined in a
future version of MATLAB
% handles structure with handles and user
data (see GUIDATA)
close(deber)
% --- If Enable == 'on', executes on mouse
press in 5 pixel border.
% --- Otherwise, executes on mouse press in 5
pixel border or over boton1.
function boton1_ButtonDownFcn(hObject,
eventdata, handles)
function seno_Callback(hObject, eventdata,
handles)
set(handles.cos,'value',0)
set(handles.tan,'value',0)
set(handles.sec,'value',0)
set(handles.grafec,'value',0)
op=get(handles.seno,'value');
if op==1
x=0:0.05:10;
y=sin(x)
plot(x,y); grid
end
function cos_Callback(hObject, eventdata,
handles)
set(handles.seno,'value',0)
set(handles.tan,'value',0)
set(handles.sec,'value',0)
set(handles.grafec,'value',0)
op=get(handles.cos,'value');
14
if op==1
x=0:0.05:10;
y=cos(x)
plot(x,y); grid
end
% Hint: get(hObject,'Value') returns toggle
state of cos
% --- Executes on button press in tan.
function tan_Callback(hObject, eventdata,
handles)
% hObject handle to tan (see GCBO)
% eventdata reserved - to be defined in a
future version of MATLAB
% handles structure with handles and user
data (see GUIDATA)
set(handles.seno,'value',0)
set(handles.cos,'value',0)
set(handles.grafec,'value',0)
set(handles.sec,'value',0)
op=get(handles.tan,'value');
if op==1
x=0:0.2:10;
y=tan(x)
plot(x,y); grid
end
% Hint: get(hObject,'Value') returns toggle
state of tan
% --- Executes on button press in sec.
function sec_Callback(hObject, eventdata,
handles)
% hObject handle to sec (see GCBO)
% eventdata reserved - to be defined in a
future version of MATLAB
% handles structure with handles and user
data (see GUIDATA)
set(handles.cos,'value',0)
set(handles.tan,'value',0)
set(handles.seno,'value',0)
set(handles.grafec,'value',0)
op=get(handles.sec,'value');
if op==1
x=0:0.2:10;
y=sec(x);
plot(x,y); grid
end
% Hint: get(hObject,'Value') returns toggle
state of sec
% --- Executes on button press in grafec.
function grafec_Callback(hObject, eventdata,
handles)
% hObject handle to grafec (see GCBO)
% eventdata reserved - to be defined in a
future version of MATLAB
% handles structure with handles and user
data (see GUIDATA)
set(handles.int,'visible','on')
set(handles.boton4,'visible','on')
set(handles.yigual,'visible','on')
set(handles.borrar,'visible','on')
set(handles.cos,'value',0)
set(handles.tan,'value',0)
 15

set(handles.seno,'value',0)
set(handles.sec,'value',0)

% Hint: get(hObject,'Value') returns toggle

state of grafec

function int_Callback(hObject, eventdata,

handles)
creation, after setting all properties.
function int_CreateFcn(hObject, eventdata,
handles)
if ispc &&
isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end

% --- Executes on button press in borrar.

function borrar_Callback(hObject, eventdata,
handles)
set(handles.ordened,'string',' ')
set(handles.lapl,'string',' ')
set(handles.y3,'string',' ')
set(handles.y2,'string',' ')
set(handles.y1,'string',' ')
set(handles.y,'string',' ')
set(handles.x,'string',' ')
set(handles.cci1,'string',' ')
set(handles.cci2,'string',' ')
set(handles.cci3,'string',' ')
set(handles.cci4,'string',' ')
set(handles.resultado,'string',' ')
set(handles.resultado2,'string',' ') IV.ANÁLISIS DE VOZ
set(handles.int,'string',' ')

El análisis de voz propiamente no es funcional pues el modelo

% --- Executes during object creation, after
setting all properties.
function plot_CreateFcn(hObject, eventdata,
handles)
% --- Executes on button press in graficax.
function graficax_Callback(hObject, eventdata,
handles)
d=get(handles.resultado,'string');
syms x y;
ezplot(handles.axes2,d,[-10,20]);
que corresponde a la modulación interactiva y las distintas
frecuencias que aunque estan sometias a un rango especifico
varian en un numero infinito, por esta razón el estudio se
refiera a la acustica en si como un modo de generar modelos
simples los cuales se van acoplando a las necesidades de la
investigación en la cual es requerido, y es así como muchas de
estas investigaciones han aportado soluciones efectivas para el
desarrollo de mejores programas de reconocimiento de voz.
Introducción a modelos físicos

¿Cuál es la causa de que la presión de aire fluyendo a través de

un tubo hueco produzca ondas de presión en el aire del
exterior que conocemos como notas? Con modelos físicos se
intenta describir matemáticamente la acústica de los
instrumentos tradicionales y implementar digitalmente los
algoritmos para poder reproducir estos fenómenos.

En la actualidad se ha desarrollado suficientamente la

tecnología para que se puedan manipular estos modelos al
mismo nivel que los originales acústicos en tiempo real, y por
eso han sido objeto de mucho interés comercial. Pero, por
supuesto, la imitación nunca puede ser mejor que el original,

así que todavía la intención principal es descubrir la naturaleza
de los instrumentos.
Al contrario de la síntesis tradicional de muestras, se gobierna
un modelo físico por la interfaz entre el ejecutante y el
instrumento.Variables como la presión de aire y la
embocadura para instrumentos de viento y la presión del arco
y posición del dedo para los de cuerdas fijan qué oscilaciones
afectan al medio resonante, que como consecuencia emite
ondas sonoras a su entorno. Con ello se ha perdido la
generalidad de la síntesis muestreada y la posibilidad de influir
la señal directamente, a cambio de un control del modelo más
amigable al usuario, intuitivo y tradicional.
Los modelos físicos requieren menos capacidad de datos que
la síntesis muestreada si hay algoritmos efectivos, pero los
gastos elevados se encuentran al desarrollar estos algoritmos
que es necesario adaptar a medida para cada tipo de
instrumento que tiene distintos fenómenos acústicos.
Así como la síntesis de muestras ha contribuído a clasificar los
distintos instrumentos por su timbre, los modelos físicos han
contribuido a refinar la clasificación por sus cualidades físicas.
Los dos grupos principales son instrumentos de cuerdas e
instrumentos de viento, ambos subdivididos en varios grupos.
Para modelar un instrumento se divide en dos partes
funcionales: el excitador y el resonador. El excitador se puede
simular como una señal entrada no lineal para el resonador, el
cuál se puede modelar como una función transferencia lineal
que produce la señal salida audible. Los dos se unen con
realimentación.
La teoría más aplicada para el resonador de modelos físicos es
la denominada ³teoría de guía de ondas². Se basa en la
solución analítica de la ecuación de la propagación de ondas
en el material. La ecuación es adecuada para cualquier guía de
ondas unidimensional, tanto cuerdas como tubos huecos:
Ky² = Eÿ
Para cuerdas:
K = tensión de la cuerda
E = densidad de masa lineal
y = desplazamiento de la cuerda
ÿ = aceleración de la cuerda
y² = curvatura de la cuerda
Además hay que modelar las pérdidas de energía debido a la
resistencia del aire, la rigidez, la fricción interno etc., que hace
apagarse al sonido. Se puede implementar todo eso muy
16
efectivamente mediante componentes digitales como líneas de
retardo, unidades de acoplo y filtros.
El excitador al ser no lineal es más dificil de modelar que el
resonador. Además existen diferentes tipos que implican
diferentes conjuntos de ecuaciones, pero hay buenos modelos
para estos también. Para mantener una nota constante el
excitador tiene que proprocionar exactamente la misma
energía que desaparece en el resonador; un cambio en la
energía proporcionada da un cambio correspondiente en la
potencia sonora. Cada resonador tiene límites superior e
inferior que determinan qué suministro de energía resulta en
un sonido conteniendo la frecuencia fundamental de la nota
deseada.
Diferentes opciones para desarrollos posteriores
En principio esta línea de investigación no tenía un fin
comercial, sino que era un intento de entender la acústica de
los instrumentos acústicos. Hoy día los algoritmos resultantes
son tan efectivos, la capacidad de cálculo tan elevada y la
interfaz al ejercitante tan buena que también es un método de
producir instrumentos musicales comerciales. En esta tarea,
hay ángulos diferentes de acometer los problemas. En un
extremo está el físico que analiza los mecanismos de
generación, en el otro está el diseñador de instrumentos que
desea buenos resultados en la calidad del sonido.
Uno de los problemas básicos y hasta ahora no resueltos es el
de los pequeños márgenes, que son tan importantes. Un
cambio minúsculo de p.ej. la presión de arco o la embocadura
produce cambios bastante audibles, y aún es un misterio qué
separa un violín bueno y uno excelente. Hay que bajar a un
nivel muy detallado que en cualquier otro contexto
electroacústico se podría pasar por alto, lo cual es un gran
desafío para el futuro.
Lo más importante será siempre centrarse en los aspectos
musicales aunque las matemáticas sean bastante interesantes
de por sí.
¿Por qué?
La ventaja de la acústica musical es la posibilidad de utilizar el
excelente oído humano como mecanismo de control para las
teorías deducidas, que también son aplicables para objetivos
no musicales. Por eso los modelos físicos pueden utilizar la
realidad como su hipótesis verificativa.
La finalidad será llegar un día a conocer los fenómenos
acústicos de los instrumentos tan bien que se logre mejorar y/o
construir nuevos instrumentos acústicos, y poder modelar
instrumentos ficticios inspirados en los tradicionales pero que
no necesariamente se puedan construir en la realidad.

También hay un gran interés comercial por estos modelos, ya
que son buenas copias de los instrumentos tradicionales, pero
mucho más flexibles. Se pueden presentar facilidades como
auriculares, MIDI, salida de jack, secuenciador, varios
instrumentos parecidos en el mismo modelo, y formatos
pequeños y ligeros.
V. FUNCIONES ESPECIALES
LISTA PARCIAL DE FUNCIONES
Funciones matemáticas
Funcionales especiales y elementales
-Funciones gamma, beta y elípticas.
-Transformación de sistemas de coordenadas.
-Matriz identidad y otras matrices elementales.
-Matrices de Hilbert, Toeplitz, Vandermonde, Hadamard, etc.
-Partes reales, imaginarias y complejas conjugadas.
-Funciones trigonométricas y de potencias.
Algebra lineal numérica
-Valores propios y descomposición de matrices.
-Funciones generales de evaluación de matrices.
-Determinantes, normas, rangos, etc.
-Matrices inversas y factorización de matrices.
-Matriz exponencial, logarítmica y raíces cuadradas.
Polinomios e interpolación
-Interpolación 1-D y 2-D.
-Construcción polinomial.
-Interpolación por splines cúbicos.
-Diferenciación de polinomios.
-Evaluación de polinomios.
-Multiplicación y división de polinomios.
-Residuos de polinomios y residuos.
Métodos numéricos no lineales
-Búsqueda de ceros en funciones de una única variable.
-Minimización de funciones de una o más variables.
-Resolución numérica de integrales.
17
-Solución numérica de ecuaciones diferenciales ordinarias.
Estadística y análisis de Fourier
-Convolución 1-D y 2-D.
-Filtros digitales 1-D y 2-D.
-Transformadas de Fourier 1-D y 2-D y su inversa.
-Coeficientes de correlación y matrices de covarianza.
-Deconvolución.
-Magnitudes y ángulos de fase.
-Funciones max, min, sum, mean y otras funciones de
estadística básica.
Operaciones algebráicas y lógicas
-Suma, resta, multiplicación, división y potencias de matrices.
-Matrix traspuesta.
-Operadores lógicos AND, OR, NOT y XOR.
Utilidades
-Gestión y mantenimiento de errores.
-Conversión de tipos de datos Fortran.
-Funciones de fecha y hora.
-Clasificación de matrices.
-Conversión de números a cadenas y viceversa.
VI. Conclusiones
En conclusión, vemos que Matlab nos sirve de mucho:
-El cual contiene diferentes comandos con los cuales podemos
realizar diferentes funciones. Sabiendo utilizar los comandos
adecuados, pudimos aprender a modelar de una manera
práctica y clara la función de transferencia de cualquier
sistema.
-De aprendieron algunas herramientas en Matlab para
utilizarlas en los intervalos de la gráfica.
-Se aprendió en esta práctica a graficar tres funciones en una
sola gráfica, con sus intervalos, puntos de la función.
La importancia de esta práctica, es que además de anexar una
lista de comandos en un lenguaje de instrucciones se busca en
general el entendimiento del proceso, las funciones que
ejercen los comandos introducidos por el usuario, tienen una
función determinada, lo que se busca es facilitar estos
 18

procesos que requieren que se resuelvan a papel y lápiz, pero
con solo entender lo que se necesita realizar, podemos lograr
estos cálculos utilizando de manera esencial la '
herramienta Matlab.
VII. Bibliografías
1. https://www.academia.edu/16487217/Introduccion_y
_conclusion_de_matlab
2. https://la.mathworks.com/campaigns/products/trials.h
tml?s_eid=ppc_51960033056&q=matlab&gclid=Cjw
KCAiA0O7fBRASEiwAYI9QAisWkWgXQaYrq_A
SSsKvQrAwBODK6E1nCliorGhWpea3AHPRmAtip
RoCLVIQAvD_BwE
3. https://www.mathworks.com/products/matlab.html
4. https://la.mathworks.com/
5. https://warwick.ac.uk/services/its/servicessupport/sof
tware/list/matlab/
6. http://webs.ucm.es/centros/cont/descargas/documento
11541.pdf
7. http://personales.upv.es/jbenitez/data/matlab.pdf
8. https://sergioyansen.wordpress.com/tag/ecuaciones-
diferenciales-reducibles-a-variables-separables/
9. https://es.slideshare.net/LGEBRALINEALECUACI
ON/ecuaciones-diferenciales-de-variables-separables-
y-ecuaciones-diferenciales-reducibles-a-variables-
separables
10. https://matematicasies.com/Ecuaciones-
Diferenciales-Reducibles-a-Variables
En la actualidad estudia en la Universidad de las Fuerzas
Armadas Espe-Latacunga, en Segundo Semestre de la carrera
de ingeniería en Electrónica y Automatización.
Luis Quishpe nació en Quito-
Ecuador, 22 de noviembre de
1998.
Estudio en la primaria en la
escuela Unidad Educativa Pedro
Luis Calero ubicada en San Isidro
del Inca ciudad de Quito–
Ecuador en el año 2008, en el
secundario estudio en la Unidad
Educativa Pedro Luis Calero (solo
8vo de Básica) ubicado en San
Isidro del Inca ciudad de Quito– Ecuador en el año 2009 y en
el Instituto Tecnológico Superior Central Técnico ubicado en
los Sauces ciudad de Quito-Ecuador en el año 2016.
En la actualidad estudia en la Universidad de las Fuerzas
Armadas Espe-Latacunga, en Segundo Semestre de la carrera
de ingeniería en Electrónica y Automatización.

David Ruiz nació en Salcedo

Ecuador, el 4 de abril del 2000.
Estudio en la primaria en la
escuela Madison High School
Ubicada en Salcedo – Ecuador en
el año 2010, en el secundario
estudio en el colegio técnico
Ramon Barba Naranjo ubicada en
Latacunga-Ecuador en el año
2016.
En la actualidad estudia en la Universidad de las Fuerzas
Armadas Espe-Latacunga, en Segundo Semestre de la carrera
de ingeniería en Electrónica y Automatización.

Ariel Quishpe nació en Quito-

Ecuador, 7 de noviembre de 1998.
Estudio en la primaria en la
escuela San Vicente ubicada en la
vicentina ciudad de Quito–
Ecuador en el año 2008, en el
secundario estudio en el colegio
Juan Montalvo ubicado en la
Gasca ciudad de Quito-Ecuador en
el año 2016.