Interfaz Grafica para la

Optimizacion de Procesos de
Produccion.

Marlyth Leggs Romero

Matrcula 30138
Maestra en Ciencias de la Ingeniera
Septiembre de 2015
Indice
1. Introduccion 3

2. Objetivo 3

3. Justificacion 4

4. Metodologa 4

5. Resultados obtenidos 5

6. Conclusiones 11

7. Anexos 13

CETYS Universidad 2
 Resumen
Este proyecto presenta el desarrollo de una herramienta sencilla y eficaz utili-
zada para la optimizacion de procesos de produccion, la cual permitira, mediante
metodos de programacion lineal, encontrar las condiciones optimas que permitan
lograr el maximo rendimiento y/o el menor costo.

Palabras Clave: Optimizacion, Programacion Lineal, SIMPLEX

1. Introduccion
Existen varios metodos muy eficaces que permiten hacer el estudio de maxi-
mizacion y/o minimizacion de recursos y costos. Sin embargo, la mayora de las
empresas tienen pocas nociones o simplemente no tienen ningun conocimiento
de la existencia o el manejo de dichas herramientas. Por otra parte, los progra-
mas que ofrecen este recurso generalmente son muy difciles de manejar lo que
dificulta aun mas el analisis del problema para quienes no estan familiarizados,
ya sea, con el programa o con el metodo.

El proyecto presentado a continuacion esta enfocado en aquellos metodos que

utilizan la programacion lineal para resolver los problemas planteados.El objetivo
principal es desarrollar una interfaz en la que se pueda analizar detalladamente
y de manera sencilla todas las actividades, recursos y variables que integran el
proceso, con la finalidad de encontrar las condiciones optimas que permitan lo-
grar el maximo rendimiento o el menor costo.

Sin embargo, si sera muy importante que el usuario logre definir la problemati-
ca a resolver mediante un modelo matematico que permita ser analizado por el
sistema ha desarrollar. Los principales problemas a resolver seran aquellos que
involucran maximizacion de utilidades o beneficios, as como la minimizacion de
costos relacionados al problema de transporte, siempre y cuando las problemati-
cas cumplan con las condiciones soportadas por el sistema programado.

2. Objetivo
Crear una herramienta flexible que permita optimizar, problemas involucra-
dos con procesos de produccion para obtener un beneficios maximos o la reduc-
cion de costos en la asignacion de recursos en los problemas de transporte.

CETYS Universidad 3
 3. Justificacion
En la actualidad, los programas que existen para hacer estudios de opti-
mizacion resultan ser bastante complejos para aquellas personas que no estan
familiarizados con estos sistemas.

Es por ello que es necesario que en las empresas se cuente con un mecanismo
sencillo que permita analizar, evaluar, y optimizar procesos industriales a cual-
quier persona que este interesada en hacerlo.

4. Metodologa
El presente proyecto esta enfocado en resolver problemas los cuales esten
relacionados con Programacion Lineal, la cual es una tecnica que tiene como
objetivo asignar de la mejor forma posible los recursos limitados entre las acti-
vidades que se involucran, ya sea para maximizar o minimizar una funcion lineal.

Para lograr hacer que la interfaz grafica arroje valores confiables sera necesa-
rio que primero se plantee un modelo matematico del problema, que generalmente
solo esta presentado de forma verbal. Los elementos basicos del modelo son la
Funcion Objetivo, la cual representa la ecuacion que se desea optimizar, las va-
riables que se involucran dentro del modelo y por ultimo las restricciones de los
recursos.

Una vez planteado el modelo y ya asignados los valores en las casillas de la

interfaz, el programa procedera a resolver el problema mediante el metodo SIM-
PLEX, el cual es un metodo iterativo que consiste en evaluar la funcion objetivo
en cada una de sus posibles soluciones hasta encontrar la solucion optima de
maximizacion o minimizacion segun sea el caso.

Es importante mencionar que la codificacion del sistema se hara a traves del

software matematico MATLAB version R2010a.

CETYS Universidad 4
 5. Resultados obtenidos
Una vez iniciando el software matematico automaticamente se abrira una
ventana en la cual se deben introducir los datos del modelo matematico que re-
presenta el problema a resolver. Por cuestiones de capacidad, el software creado
tiene como lmite el uso de un maximo de 8 variables y hasta 10 restricciones
posibles, ademas, el algoritmo solo funcionara en aquellos problemas cuyas res-
tricciones tengan un lmite superior (restrecciones con menor igual) esto con
el fin de evitar confuisones a aquellos usuarios que no esten relacionados con el
planteamiento de los modelos matematicos en el metodo SIMPLEX.

Figura 1: Ventana de inicializacion.

Para poder explicar mejor el uso de la interfaz, se presentara un problema

planteado en el libro de Jimenez y Quesada [4].

CETYS Universidad 5
 En un almacen de frutas hay 800 kg de naranjas, 800 kg de manzanas y 500
kg de pl atanos. Para su venta se hacen dos lotes A y B. El lote A contiene 1
kg de naranjas, 2 kg de manzanas y 1 kg de platanos; el lote B se compone de 2
kg de naranjas, 1 kg de manzanas y 1 kg de platanos. El beneficio por kg que se
obtiene con el lote A es de $1200 M. N y de $1400 M. N. con el lote B. Determinar
cuantos kilogramos de cada tipo se necesitan para obtener un beneficio maximo.

Lo primero que hay que hacer para poder plantear al modelo matematico es
definir las variables:

XA : Numero de lotes tipo A por formar.

XB : Numero de lotes tipo B por formar.

Sabiendo que las utilidades son de $1200 y $1400 respectivamente, entonces

la Funcion Objetivo quedara de la siguiente manera:

M axZ = 1200XA + 1400XB (1)

El siguiente paso es representar las restricciones a manera de ecuacion. Segun
el problema, el lote A se compone de 1 kg de naranjas, y a su vez, el lote B se
compone de 2 kg, sabemos que el lmite del almacen es de 800 kg de naranjas,
por lo que dicha destriccion se puede escribir de la siguiente forma:

XA + 2XB 800 (2)

Analogamente para las condiciones de manzanas y platanos, dichas ecuaciones
se enumeran como sigue:

2XA + XB 800 (3)

XA + XB 500 (4)
Una condicion importante en el analisis del metodo SIMPLEX, es que las
variables nunca deben ser negativas, es por ello que se establece la condicion de
la no negatividad, es decir:

XA , XB 0 (5)

Con la ecuacion anterior se ha terminado de plantear el modelo, es momento

ahora de introducir todos los datos a la interfaz grafica.

CETYS Universidad 6
 Una vez seleccionando el numero de variables y restricciones se deben colocar
solamente los coeficientes que corresponden a cada variable del modelo matemati-
co tal como se muestra en la Figura 2.

Figura 2: Representacion del modelo matematico en el sistema

Es importante tomar en cuenta que la colocacion de los datos debe ser precisa,
de lo contrario los resultados que arroje el sistema seran poco confiables y/o
el modelo no arrojara ninguna solucion. Posteriormente, se debe especificar el
calculo deseado (Maximizacion o Minimizacion), una vez ejecutado el algoritmo
se abrira una nueva ventana en donde apareceran los valores de la solucion optima
del modelo.

CETYS Universidad 7
 Figura 3: Ventana de resultados.

Con lo anterior se concluye que, para lograr el beneficio maximo, el almacen

debe vender 200 lotes de tipo A y 300 lotes de tipo B para alcanzar un total de
beneficios de $ 600,000 M. N.

CETYS Universidad 8
 Por otra parte, en el caso de que se desee hacer una minimizacion del modelo,
sera necesario que los coeficientes de la funcion objetivo aparezcan con el signo
contrario, esto se debe al acomodo de las celdas en el algoritmo de programacion.
Un ejemplo de ello se muestra en la siguiente imagen:

Figura 4: Problema de minimizacion.

Donde el modelo matematico representado en la Figura 4 esta dado por la

ecuacion:

M inZ = 4000X1 + 3000X2 (6)

CETYS Universidad 9
 sujeto a:

X1 6
2X2 10 (7)
15X1 + 5X2 100
X1 , X2 0

Del cual, una vez ejecutado el algoritmo se obtienen como resultados X1 =5,
X2 =5 y Z=35,000.

CETYS Universidad 10
 6. Conclusiones
Despues de ejecutar el programa a prueba y error varios ejercicios se
comprobo que los resultados que arroja el software efectivamente son los
optimos por lo que dicha herramienta demuestra ser lo suficientemente con-
fiable para su uso e implementacion en problemas de optimizacion.

Por otra parte, las principales dificultades a la hora de la utilizacion de

la herramienta fue, sin lugar a dudas, lograr que el usuario transformara
la problematica a tratar en un modelo matematico acertado. Sin embargo,
una vez logrado lo anterior y cumpliendo con los requerimientos basicos del
sistema, los resultados arrojados fueron acertados y contundentes.

Es importante mencionar que an se sigue trabajando en la mejora del

algoritmo de solucion, con el fin de brindarle al usuario mayor capacidad
de respuesta en problemas que imploquen una mayor dificultad.

CETYS Universidad 11
 Referencias
[1] Prawda, J. (2004) Metodos y modelos de investigacion de operaciones
I: Modelos determinsticos. Ed. Limusa, Mexico.
[2] Hamdy, T. (2004) Investigacion de Operaciones. 7a. Edicion. Pearson
Educacion, Mexico.
[3] Mocholi, M.; Sala, R. (1993) Programacion Lineal: Metodologa y pro-
blemas. Editorial Tebar Flores, S. L.
[4] Jimenez, G.; Quesada, V. (2006) Cien problemas de programacion li-
neal. Manizales, Colombia.
[5] Render, B; Stair, R.; Hanna, M. (2012) Metodos cuantitativos para los
negocios. 11a. edicion, Pearson Educacion, Mexico.

CETYS Universidad 12
 7. Anexos
A continuacion se presenta el algoritmo codificado en MATLAB R2010a.

f u n c t i o n v a r a r g o u t = INTERFAZ( v a r a r g i n )
clc

gui Singleton = 1;
g u i S t a t e = s t r u c t ( gui Name , mfilename , . . .
gui Singleton , gui Singleton , . . .
gui OpeningFcn , @INTERFAZ OpeningFcn , . . .
gui OutputFcn , @INTERFAZ OutputFcn , . . .
gui LayoutFcn , [] , ...
gui Callback , []);
i f n a r g i n && i s c h a r ( v a r a r g i n { 1 } )
gui State . gui Callback = str2func ( varargin {1});
end

i f nargout
[ varargout {1: nargout } ] = gui mainfcn ( gui State , varargin { : } ) ;
else
gui mainfcn ( gui State , varargin { : } ) ;
end

% E x e c u t e s j u s t b e f o r e INTERFAZ i s made v i s i b l e .
f u n c t i o n INTERFAZ OpeningFcn ( hObject , e v e n t d a t a , h a n d l e s , v a r a r g i n )
h a n d l e s . o ut pu t = hObject ;
h a n d l e s . numVar=2;
h a n d l e s . numRest =2;
h a n d l e s . t i p o =1;
s e t ( h a n d l e s .TEXTO, S t r i n g , ) ;

% Update h a n d l e s s t r u c t u r e
g u i d a t a ( hObject , h a n d l e s ) ;

% Outputs from t h i s f u n c t i o n a r e r e t u r n e d t o t h e command l i n e .

f u n c t i o n v a r a r g o u t = INTERFAZ OutputFcn ( hObject , e v e n t d a t a , h a n d l e s )

% Get d e f a u l t command l i n e ou tp ut from h a n d l e s s t r u c t u r e

v a r a r g o u t {1} = h a n d l e s . ou tp ut ;

f u n c t i o n botVARIABLES Callback ( hObject , e v e n t d a t a , h a n d l e s )

h a n d l e s . numVar=g e t ( hObject , Value ) ;
columnas = { } ;
f i l a s ={1};
f o r i =1: h a n d l e s . numVar
columnas ( i )={ s p r i n t f ( x\ %d , i ) } ;
end
orden=s i z e ( columnas ) ;
l e t r a =a ;
orden=s i z e ( f i l a s ) ;
f i l a s ( 1 ) = { Z } ;

ancho=g e t ( h a n d l e s . tablaVAR , P o s i t i o n ) ;
ancho =(276)/ l e n g t h ( columnas ) ;
s e t ( h a n d l e s . tablaVAR , ColumnWidth , { ancho } ) ;
s e t ( h a n d l e s . tablaVAR , ColumnWidth , { ancho } ) ;

s e t ( h a n d l e s . tablaVAR , RowName , f i l a s ) ;
s e t ( h a n d l e s . tablaVAR , ColumnName , columnas ) ;
s e t ( h a n d l e s . tablaVAR , ColumnEditable , t r u e ) ;

CETYS Universidad 13
 s e t ( h a n d l e s . tablaVAR , ColumnFormat , { numeric } ) ;
s e t ( h a n d l e s . tablaVAR , Data , z e r o s ( 1 , h a n d l e s . numVar ) ) ;

g u i d a t a ( hObject , h a n d l e s ) ;

% E x e c u t e s d u r i n g o b j e c t c r e a t i o n , a f t e r s e t t i n g a l l p r o p e r t i e s .
f u n c t i o n botVARIABLES CreateFcn ( hObject , e v e n t d a t a , h a n d l e s )

if i s p c && i s e q u a l ( g e t ( hObject , BackgroundColor ) , g e t ( 0 , d e f a u l t U i c o n t r o l B a c k g r o u n d C o l o r ) )

s e t ( hObject , BackgroundColor , b l u e ) ;
end

% E x e c u t e s on s e l e c t i o n change i n botRESTRICCIONES .
f u n c t i o n botRESTRICCIONES Callback ( hObject , e v e n t d a t a , h a n d l e s )
h a n d l e s . numRest=g e t ( hObject , Value ) ;
c o l=g e t ( h a n d l e s . botVARIABLES , Value ) ;
columnas = { } ;
f i l a s ={ };

f o r i =1: c o l
columnas ( i )={ s p r i n t f ( x\ %d , i ) } ;
end
orden=s i z e ( columnas ) ;
columnas ( orden (2)+1)={ R e s t r i c c i n } ;
l e t r a =a ;

f o r i =1: h a n d l e s . numRest
f i l a s ( i )={ s p r i n t f ( \ % c , l e t r a ) } ;
l e t r a=l e t r a +1;
end

orden=s i z e ( f i l a s ) ;

ancho=g e t ( h a n d l e s .TABLA, P o s i t i o n ) ;
ancho =(276)/ l e n g t h ( columnas ) ;
s e t ( h a n d l e s .TABLA, ColumnWidth , { ancho } ) ;
s e t ( h a n d l e s .TABLA, ColumnWidth , { ancho } ) ;

s e t ( h a n d l e s .TABLA,
s e t ( h a n d l e s .TABLA,
s e t ( h a n d l e s .TABLA,
s e t ( h a n d l e s .TABLA,
s e t ( h a n d l e s .TABLA,
RowName , f i l a s ) ;
ColumnName , columnas ) ;
ColumnEditable , t r u e ) ;
ColumnFormat , { numeric } ) ;
Data , z e r o s ( h a n d l e s . numRest , c o l + 1 ) ) ;

g u i d a t a ( hObject , h a n d l e s ) ;

% E x e c u t e s d u r i n g o b j e c t c r e a t i o n , a f t e r s e t t i n g a l l p r o p e r t i e s .
f u n c t i o n botRESTRICCIONES CreateFcn ( hObject , e v e n t d a t a , h a n d l e s )

if i s p c && i s e q u a l ( g e t ( hObject , BackgroundColor ) , g e t ( 0 , d e f a u l t U i c o n t r o l B a c k g r o u n d C o l o r ) )

s e t ( hObject , BackgroundColor , b l u e ) ;
end

% E x e c u t e s d u r i n g o b j e c t c r e a t i o n , a f t e r s e t t i n g a l l p r o p e r t i e s .
f u n c t i o n tablaVAR CreateFcn ( hObject , e v e n t d a t a , h a n d l e s )
s e t ( hObject , ColumnName , { } ) ;
s e t ( hObject , RowName , { } ) ;
s e t ( hObject , Data , [ ] ) ;

% E x e c u t e s d u r i n g o b j e c t c r e a t i o n , a f t e r s e t t i n g a l l p r o p e r t i e s .
f u n c t i o n TABLA CreateFcn ( hObject , e v e n t d a t a , h a n d l e s )
s e t ( hObject , ColumnName , { } ) ;

CETYS Universidad 14
 s e t ( hObject , RowName , { } ) ;
s e t ( hObject , Data , [ ] ) ;

% E x e c u t e s when e n t e r e d data i n e d i t a b l e c e l l ( s ) i n TABLA.

f u n c t i o n TABLA CellEditCallback ( hObject , e v e n t d a t a , h a n d l e s )

i=g e t ( hObject , Data ) ;

i f isnan ( i ( eventdata . I n d i c e s (1) , eventdata . I n d i c e s ( 2 ) ) )
i ( eventdata . I n d i c e s (1) , eventdata . I n d i c e s (2))=0;
s e t ( hObject , Data , i ) ;
end

% E x e c u t e s when e n t e r e d data i n e d i t a b l e c e l l ( s ) i n tablaVAR .

f u n c t i o n t a b l a V A R C e l l E d i t C a l l b a c k ( hObject , e v e n t d a t a , h a n d l e s )
i=g e t ( hObject , Data ) ;
i f isnan ( i ( eventdata . I n d i c e s (1) , eventdata . I n d i c e s ( 2 ) ) )
i ( eventdata . I n d i c e s (1) , eventdata . I n d i c e s (2))=0;
s e t ( hObject , Data , i ) ;
end

% E x e c u t e s on s e l e c t i o n change i n TIPO .
f u n c t i o n TIPO Callback ( hObject , e v e n t d a t a , h a n d l e s )
h a n d l e s . TIPO=g e t ( hObject , Value ) ;

g u i d a t a ( hObject , h a n d l e s ) ;

i f h a n d l e s . TIPO==1
s e t ( h a n d l e s .TEXTO, S t r i n g , C o l o c a r s i g n o s n e g a t i v o s en l a F u n c i n O b j e t i v o )
else
s e t ( h a n d l e s .TEXTO, S t r i n g , )
end

% E x e c u t e s d u r i n g o b j e c t c r e a t i o n , a f t e r s e t t i n g a l l p r o p e r t i e s .
f u n c t i o n TIPO CreateFcn ( hObject , e v e n t d a t a , h a n d l e s )

if i s p c && i s e q u a l ( g e t ( hObject , BackgroundColor ) , g e t ( 0 , d e f a u l t U i c o n t r o l B a c k g r o u n d C o l o r ) )

s e t ( hObject , BackgroundColor , white ) ;
end
s e t ( hObject , S t r i n g , { Minimizar , Maximizar } ) ;

% E x e c u t e s on bu tt on p r e s s i n botOPTIMIZAR .
f u n c t i o n botOPTIMIZAR Callback ( hObject , e v e n t d a t a , h a n d l e s )
A=g e t ( h a n d l e s . tablaVAR , Data ) ;
B=g e t ( h a n d l e s .TABLA, Data ) ;

s i m p l e x =[B ; A 0 ] ;
s i m p l e x = [ [ s i m p l e x ( : , 1 : h a n d l e s . numVar ) , [ e y e ( h a n d l e s . numRest ) ;
z e r o s ( 1 , h a n d l e s . numRest ) ] ] , s i m p l e x ( : , h a n d l e s . numVar + 1 ) ] ;
orden=s i z e ( s i m p l e x ) ;
b a s e =( z e r o s ( 1 , h a n d l e s . numVar ) ) ;
s i g n o =1;

i f h a n d l e s . TIPO==2
s i g n o =1;
end

w h i l e mean ( ( s i m p l e x ( orden ( 1 ) , : ) s i g n o )>=0)=1

disp ( simplex ) ;
i f h a n d l e s . TIPO==1
[ , y]=min ( s i m p l e x ( orden ( 1 ) , 1 : orden ( 2 ) 1 ) ) ;
else
[ , y]=max( s i m p l e x ( orden ( 1 ) , 1 : orden ( 2 ) 1 ) ) ;

CETYS Universidad 15
 end
x =1;
p i v o t e=s i m p l e x ( 1 , orden ( 2 ) ) / s i m p l e x ( 1 , y ) ;

f o r i =2:( orden ( 1 ) 1 ) ;
i f s i m p l e x ( i , y)>0
aux=s i m p l e x ( i , orden ( 2 ) ) / s i m p l e x ( i , y ) ;
i f p i v o t e <0 | | aux<p i v o t e
p i v o t e=aux ;
x=i ;
end
end
end

b a s e ( y)=x ;

simplex (x ,:)= simplex (x , : ) / simplex (x , y ) ;

f o r i =1: orden ( 1 ) ;
i f i =x
aux = ( 0 ) ;
f o r j =1: orden ( 2 ) ;
aux ( j )= s i m p l e x ( i , j ) s i m p l e x ( i , y ) s i m p l e x ( x , j ) ;
end
s i m p l e x ( i , : ) = aux ;
end
end
end

disp ( simplex ) ;
disp ( base ) ;

aux= SOLUCI N : ;

f o r i =1: h a n d l e s . numVar
i f b a s e ( i )=0
aux=s p r i n t f (\ % s \n x\ %d = \ %. f , aux , i , s i m p l e x ( b a s e ( i ) , orden ( 2 ) ) ) ;
else
aux=s p r i n t f (\ % s \n x\ %d = \ %. f , aux , i , 0 ) ;
end
end

aux=s p r i n t f (\ % s \n Z = \ %. f , aux , abs ( s i m p l e x ( orden ( 1 ) , orden ( 2 ) ) ) ) ;

msgbox ( aux , R e s u l t a d o s ) ;

CETYS Universidad 16