INFORME DE LABORATORIO DE OPTIMIZACION LINEAL

TEMA: INVERSA DE UNA MATRIZ

FECHA 18/08/2016

Qu es?

Es un algoritmo que permite hallar la inversa de una matriz paso a paso por
medio de iteraciones usando solo la misma matriz

Qu hace?

Realiza operaciones elementales con cada fila, de manera tal que despus de n
iteraciones se consigue la matriz inversa.

Variables:
v = guarda la matriz original
A = matriz que cambia en cada iteracion
d = tamao de la matriz
r = elemento de la matriz cuyo subndices son iguales
P = recorrido de los elementos de la matriz
K = multiplicacin de cada elemento de la matriz por uno de sus elementos

Codigo en Matlab
% Invertir matriz usando las filas
%A=input(' Ingresar Matriz A= ') % Ingresar matriz a invertir
A=[1 0 3
2 4 1
2 1 1];
v=A; % Guardar matriz original
d= max(size(A)); % Dimension de la Matriz
for i=1:d
r=A(i,i); % Recorrer elementos en la diagonal
principal
P=A(i:i,1:d)./r; % dividir fila entre r
P(1,i)=P(1,i)/r; % dividir el pivote entre r
A(i:i,1:d)=P; % guardar fila pivote
for j=1:d
if j~=i
K=P.*A(j,i);
A(j,i)=0;
A(j:j,1:d)=A(j:j,1:d)-K;
end
end
A;
end
inv=A % Comprobar resultado
Ide=A*v

Ejecucion del programa

INFORME DE LABORATORIO DE OPTIMIZACION LINEAL

TEMA: METODO SIMPLEX
FECHA 25/08/2016
Qu es?
Se entiende por programa lineal aquel que optimiza

Donde la funcin lineal (8) se llama funcin objetivo; las desigualdades (9) se
llama restricciones y a (10) es la condicin de no negatividad. La optimizacin
puede significar maximizar o minimizar.

Qu hace?

Resuelve la programacin lineal en iteraciones. Cada iteracin desplaza la

solucin a un nuevo punto esquina que tienes potencial de mejorar el valor de
la funcin objetivo. El proceso termina cuando ya no se pueden obtener
mejoras.

Variables:
I= matriz original
A = matriz
f*c = tamao de la matriz
n = nmero de ecuaciones
vv = nmero de variables
k = ndice de columna (mas negativo)
M(r,k) = posicin
p = el minimo de la matriz
piv = pivote a escoger
Mp = fila donde se encuentra el pivote

En el Cdigo se harn ms especificaciones

Codigo en Matlab
% Guardar en MM la Matriz que constara de funacion objetivo,
% Matriz de restricciones y matriz b
% Ejm MM= [5000 3000 0
% 3 5 15
% 5 2 10 ]
I=MM
[f,c] = size(I); % tamao de la matriz fxc
v=c-1; % numero de variables
n=f-1; % numero de ecuaciones
% Construccion del Tablero Simplex
M=zeros(f,c+n);
M(1:1,1:v)=-I(1:1,1:v);
M(2:f,1:v)=I(2:f,1:v);
M(2:f,v+1:v+n)=eye(n);
M(2:f,c+n:c+n)=I(2:f,c:c)
c=c+n; % Columnas de M
xi=(v+1:1:v+n)'; % Indicador de variables en la Base
for i=1:n
%indice de columna a tomar (mas negativo)
k=min(find(M(1:1,1:c-1)==min(M(1:1,1:c-1))));
%Pivote a escoger y su posicion
pp=M(2:f,c:c)./M(2:f,k:k);
% Hacer todos los componentes del vector pp positivos
% -------------------
d=abs(max(pp))+1;
for w=1:n
if pp(w)<0
pp(w)=d;
end
end
% ------------------
p=min(pp);
r=find(pp==p)+1; % Fila donde esta el pivote
piv=max(M(r,k)); % Valor del pivote
%dividir la fila donde se encuenrta el pivote entre p
Mp=M(r:r,1:c)./piv; % Fila Pivote
M(r:r,1:c)=Mp;
for j=1:f % Se hacen operaciones con la fila pivote
if j~=r
w=max(M(j:j,k:k));
M(j:j,1:c)=M(j:j,1:c)-(Mp*w);
end
end
M % Visualizar resultado de la iteracion
xi(r-1,1)=k; % Identificar variable que ingresa ala base
end
xi(1:n,2:2)=M(2:f,c:c)
z=M(1,c)

Ejemplo
Ejecucion del programa
INFORME DE LABORATORIO DE OPTIMIZACION LINEAL
TEMA: METODO DE PENALIZACION BIG M
FECHA: 01/09/2016

Qu es?

El mtodo comienza con la programacin lineal en forma de ecuacin. Una

ecuacin i que no tenga una holgura (o una variable que pueda hacer el papel
de una holgura) se aumenta con una variable artificial, Ri, para formar una
solucin de inicio parecida a la solucin bsica con todas las holguras. La
solucin final ser como si las variables artificiales nunca hubieran existido en
primer lugar. El resultado deseado se obtiene penalizando las variables
artificiales en la funcin objetivo.

Dado M, un valor positivo suficientemente grande (matemticamente, M ),

el coeficiente objetivo de la variable artificial representa una penalizacin
adecuada si:

Al usar esta penalizacin, el proceso de optimizacin forzar en forma

automtica a las variables artificiales para que sean cero (siempre que el
problema tenga una solucin factible).

Qu hace?

La aplicacin de la tcnica M implica, tericamente, que M . Sin embargo,

al usar la computadora M debe ser finito, pero suficientemente grande. Al
mismo tiempo no debe ser tan grande como para perjudicar la exactitud de los
clculos smplex, al manipular una mezcla de nmeros muy grandes y muy
pequeos.

Variables:

En el Cdigo se harn ms especificaciones

Codigo en Matlab

classdef bigM < handle

% El algoritmo implementa el mtodo grande de M Simplex para resolver
un Problema de programacin lineal en el siguiente formato
% min/max c'x
% s.t. Ax {>=, =, <=} b
% x >= 0
% % El cdigo est diseado para problemas pequeos solamente, ni
adecuados para problemas grandes ni lo suficientemente potente para la
computacin de alto rendimiento.

properties(SetAccess = private)
A; % Matriz de restricciones in Ax {<=, =, >=} b
b; % Recursos
c; % Vector de coeficientes de function
inq; % m dimension del vector,
% 1 for >=; 0 for ==; -1 for <=.
m; % Numero de restricciones
n; % Numero de variables originales
x_opt; % solution optima
fval; % Valor objetivo ptimo
type; % Minimizar o maximizar el problema
end

properties( Access = private )

M; % bigM

n_slack; % Numero de variables slack aadidos

n_artfVar; % Numero de variables artificiales aadidas
artfcl_var_set % indice de las variables artificiales
artfcl_var_removed = 1; % 1, si se quita

counter = 1; % contador de iteraciones

basis; % Vector de ndices de variables bsicas

reducedCost;
whichRow;

tab; % Tableau
status; % maxIter, ilimitado, imposible, ptimo
terminate;
vars_list; % Lista de nombres de todas las variables
unbounded_vars; % variables sin restriccion
end

properties( Constant )
maxIter = 20;
end

methods

function p = bigM(A,b,c,inq, type)

 % CONSTRUCTOR

% Comprobar entrada
if nargin < 4
error('bigM: Entrada insuficiente');
end

%% Leer la entrada
% Comprobar min o max
if strcmpi(type,'max')
c = -c;
end

% Compruebe si b es negativo
b_Neg = b < 0;
inq(b_Neg) = -inq(b_Neg);
b(b_Neg) = -b(b_Neg);
A(b_Neg,:) = -A(b_Neg,:);

% Asignar propiedades
p.A = A; p.b = b; p.c = c;
p.inq = inq;
p.terminate = 0;

% Establecer el valor de M grande!

p.M = ceil(max(norm(A),norm(b))/100)*100;

[p.m, p.n] = size(A);

% Formar la lista de variables

p.vars_list = cell(1,p.n);
for i=1:p.n
p.vars_list{i} = ['x' num2str(i)];
end

p.type = type;
end

%% Funcin del controlador

function solve(p)
% SOLVE Esta es la funcin del controlador para bigM que en realidad
% Resuelve el problema dado.

p.transform_to_standardForm;
p.construct_initial_tableau;
p.printTab;
while ~p.terminate
p.do_simplex_iterate;
p.increment_counter;
p.printTab;
p.remove_artfcl_vars;
p.check_termination;
end
p.output_summary;
end
function transform_to_standardForm(p)
% aadir variables slack
p.n_slack = sum(p.inq < 0)+sum(p.inq > 0);
p.A = [p.A zeros(p.m, p.n_slack)];
p.c = [p.c; zeros(p.n_slack,1)];
idx_slack = p.n+1;
for i = 1:p.m
switch p.inq(i)
case 1 % >=
p.A(i, idx_slack) = -1;
idx_slack = idx_slack+1;
p.vars_list{end+1} = ['s' num2str(i)];
case -1 % <=
p.A(i, idx_slack) = 1;
idx_slack = idx_slack+1;
p.vars_list{end+1} = ['s' num2str(i)];
end
end
end

function construct_initial_tableau(p)
% Encontrar una base potencial
for i = 1:p.n+p.n_slack

if nnz(p.A(:,i)) == 1
row_number = find(p.A(:,i) == 1);
if ~isempty(row_number)
% Aade la columna si no se ha seleccionado la fila actual
if ~ismember(row_number, p.whichRow)
p.whichRow(end+1) = row_number;
p.basis(row_number) = i;
end
end
end
end
% Aadir bigM si es necesario
p.n_artfVar = p.m - sum(p.basis > 0);
if p.n_artfVar > 0
p.artfcl_var_removed = 0;

% Registrar el ndice de variables artificiales

p.artfcl_var_set = (p.n + p.n_slack+1) : (p.n + p.n_slack + p.n_artfVar);

p.A = [p.A zeros(p.m,p.n_artfVar)];

add_to_rows = setdiff(1:p.m, p.whichRow);

% Formular la matriz A con variabless artificiales recin agregados

for i = 1:length(add_to_rows)
p.A(add_to_rows(i), p.n+p.n_slack+i) = 1;
p.vars_list{end+1} = ['a' num2str(i)];
p.basis(add_to_rows(i)) = p.n+p.n_slack+i;
end

p.c = [p.c; p.M*ones(p.n_artfVar,1)];

 end

% Obtener reducedCost
p.reducedCost = zeros(1,p.n + p.n_slack + p.n_artfVar);
y = p.c(p.basis);

p.reducedCost = (p.c - p.A'*y)';

% Construir tableau inicial

p.tab = [p.A p.b];
p.tab = [p.tab; [ p.reducedCost -p.b'*y ]];
end

function do_simplex_iterate(p)
% DO_SIMPLEX_ITERATE Realiza una iteracin del mtodo simplex.

% Encontrar el menor costo reducido

[~, workCol] = min( p.tab(end,1:end-1) );

% Elija la proporcin ms pequea posible

work_col_positive_elems = find( p.tab(1:end-1,workCol) > 0 );

[~, chooseRow] = min( p.tab(work_col_positive_elems, end) ./...

p.tab(work_col_positive_elems, workCol) );
chooseRow = work_col_positive_elems(chooseRow);

% In/out basis
p.basis(chooseRow) = workCol;

% Obtener el pivote
pivot = p.tab(chooseRow, workCol);

% Eleminar elementos en la columna

% Y actualizar el valor de los elementos en el tableau.
p.tab(chooseRow, :) = p.tab(chooseRow,:) / pivot;

tmp_row_indx = setdiff(1:p.m+1,chooseRow);
p.tab(tmp_row_indx, :) = p.tab(tmp_row_indx, :) -...
ones(p.m,1) * p.tab(chooseRow,:) .*...
( p.tab(tmp_row_indx, workCol) *...
ones(1,size(p.tab,2)) );
end

function remove_artfcl_vars(p)
% Comprobar si se pueden eliminar variables artificiales
if ~p.artfcl_var_removed
if all( p.tab(end, p.artfcl_var_set) > 0 )
p.tab(:,p.artfcl_var_set) = [];
p.vars_list( p.artfcl_var_set ) = [];
p.artfcl_var_removed = 1;
p.printTab;
end
end
end
 function increment_counter(p)
p.counter = p.counter+1;
end
function printTab(p)

for i=1:p.m+1
if i <= p.m
fprintf('%2s | ', p.vars_list{p.basis(i)});
else
fprintf('---------------------------------------------\n');
fprintf('%2s | ', 'RC');
end
for j = 1:size(p.tab,2)
fprintf('%8.2f %4s', p.tab(i,j), '');
if j == size(p.tab,2)-1
fprintf(' | ')
end
end
fprintf('\n');
end

end

function output_summary(p)
if p.terminate
fprintf('\n========== ========== ==========\n');
fprintf('Terminado. \n');
switch lower( p.status )
case 'optimal'
fprintf('Solucion optima: \n');
for i=1:p.n
fprintf('x[%2d ] = %5.2f\n', i, p.x_opt(i));
end
fprintf('Valor optimo de la funcion objetivo: %5.2f\n', p.fval);

case 'ilimitado'
fprintf('el problema es ilimitado. \n');
fprintf('variables ilimitadas: ');

for i = 1:length(p.unbounded_vars)
fprintf('%2s ',p.vars_list{p.unbounded_vars(i)});
end
fprintf('\n');

case 'imposible'
fprintf('problema imposible.\n');
case 'maxiter'
fprintf('numero maximo de iteraciones encontrado.\n');
end

end
end
end
end
Ejemplo1
% max 2x1 + 3x2
% s.t. x1 + 4x2 <= 4
% 2x1 + 3x2 <= 6
% 2x1 + x2 <= 4
% x1>=0, x2>=0.
c = [ 2 3 ]';
A = [1 4; 2 3 ; 2 1];
b = [4 6 4]';
inq = [-1 -1 -1];

p = bigM(A,b,c,inq,'max'); p.solve;

Ejecucion del programa

Ejemplo 2

% min -3x1 + x2 + x3
% s.t. x1 - 2x2 + x3 <= 11
% -4x1 + x2 + 2x3 >= 3
% -2x1 + x3 = 1
% x1, x2, x3>=0.
c=[-3 1 1]';
b=[11 3 1]';
A=[1 -2 1;-4 1 2;-2 0 1];
inq=[-1 1 0];
p = bigM(A,b,c,inq,'min'); p.solve;

Ejecucion del programa

INFORME DE LABORATORIO DE OPTIMIZACION LINEAL
TEMA: METODO DE DOBLE FASE
FECHA: 08/09/2016

Qu es?

En el mtodo M, el uso de la penalizacin, M, puede conducir a un error de

redondeo.
El mtodo de dos fases elimina el uso de la constante M. Como su nombre lo
indica, el mtodo resuelve la PL en dos fases; en la fase I se trata de encontrar
la solucin factible bsica inicial y, si se halla una, se invoca la fase II para
resolver el problema original.

Qu hace?

Fase I. Ponga el problema en forma de ecuacin y agregue las variables

artificiales necesarias a las restricciones (exactamente como en el mtodo M),
para tener la certeza de una solucin bsica. A continuacin, determine una
solucin bsica de la ecuacin resultante que siempre minimice la suma de las
variables artificiales, independientemente de si la PL es de maximizacin o
minimizacin. Si el valor mnimo de la suma es positivo, el problema de PL no
tiene una solucin factible. De lo contrario, si el valor mnimo es cero, prosiga
con la fase II.

Fase II. Use la solucin factible de la fase I como una solucin factible bsica
inicial para el problema original.

Paso 1. Seleccione una variable artificial cero que salga de la solucin bsica y
designe su fila como fila pivote. La variable de entrada puede ser cualquier
variable no bsica (y no artificial) con un coeficiente diferente de cero (positivo
o negativo) en la fila pivote.
Realice la iteracin simplex asociada.
Paso 2. Elimine la columna de la variable artificial (que acaba de salir) de la
tabla. Si ya se eliminaron todas las variables artificiales, contine con la fase II.
De lo contrario, regrese al paso 1.

Variables:

Codigo en matlab

function [cuadro]=simplex2fases(f,A,b)

% f = funcion de costo objetivo

% A = constantes de restricciones, las restricciones deben ser menor o
% igual al recurso
% b = recursos

m=size(A,1); % nmero de ecuaciones

B=eye(m); % identidad (para variables de holgura o para variables artificiales)
CB=zeros(1,m); % costos bsicos (son las variables de holgura, se suponen en cero)
CN=f; % costos no bsicos deben ser entregados en la funcion a minimizar

a=b<0; % se debe analizar si alguno de los recursos es menor que cero

if sum(a)==0
N=A; % no se necesitan variables artificiales
Art=0;
else
N=[A B]; % se necesitan variables artificiales
Art=1;
for i=1:1:size(b,1) % revisar paso a paso los recursos (si encuentra alguno
negativo debe ingresar variable artificial
if b(i)<0 % si alguno de los recursos es menor que cero
N(i,:)=-1*N(i,:); % multiplicar la ecuacin de la restriccin por menos 1
b(i)=-1*b(i); % cambiar el recurso al valor positivo
end
end
end

if Art==0 % no se usan variables artificiales

[cuadro]=simplex(f,A,b); % resolver por el mtodo simplex normal
else
%% Simplex de dos fases

%% fase 1

Cb1=ones(1,m); % costos de las variables artificiales

Cn1=zeros(1,size(N,2)); % costos variables no basicas fase 1
 CN=[CN zeros(1,m)]; % costos variables no bsicas problema original

cuadro=[ 1 zeros(1,m) Cb1*N-Cn1 Cb1*b;

zeros(m,1) B N b ];

cuadro=[ 1 zeros(1,m+1) CB*N-CN CB*b;

zeros(m+1,1) cuadro];

cuadro=simplexR(cuadro,m,B,N,CB,CN); % devuelve resultado de fase 1

% invB=cuadro(2:end,2:m+1)

end

function [cuadro]=simplexR(cuadro,m,B,N,CB,CN)

[fase,f,c]=fases(cuadro);

if (factibilidad(cuadro,c) ==1 )
if(optimalidad(cuadro,m,c,fase) == 1)
msgbox('cuadro ptimo')
else
while (optimalidad(cuadro,m,c,fase) ~= 1)
if fase ~= 3
[fase,f,c]=fases(cuadro);
end
if fase==2
cuadro(2,:)=[];
cuadro(:,2)=[];
fase=3;
end
if optimalidad(cuadro,m,c,fase) == 1
break
end

[V1,p1]=max(cuadro(f,c+m+1:end-1));
% mximo valor columna pivote V valor P posicin
columna=cuadro(f+1:end,end)./cuadro(f+1:end,c+m+p1);
% se dividen los recursos entre la columna pivote
positivo= columna >= 0;
% slo los valores positivos participan
a=(positivo).*columna;
% guardar los valores positivos
a(a==0)=inf;
% si existen valores cero se colocan en infinito
[V2,p2]=min(a);
% valor de la variable de bloqueo (index fila pivote)
fila=cuadro(f+p2,:); % fila pivote
Epiv=cuadro(f+p2,c+m+p1); % elemento pivote
cuadro(p2+f,:)=cuadro(p2+f,:)/Epiv;
for i=1:1:(m+f)
if i~=(p2+f)
cuadro(i,:)=cuadro(i,:)-(cuadro(i,c+m+p1)*(cuadro(p2+f,:)));
end
end
cuadro % se muestra el cuadro en cada iteracin
end
end
else
msgbox('no se puede hacer nada an')
end

identidad=eye(size(cuadro,1)-1);
for i=1:1:size(identidad,2)
for j=3:1:size(cuadro,2)-1
a=identidad(:,i)==cuadro(2:end,j);
 if a
for n=1:1:size(identidad,2)
if cuadro(1+n,j)== 1
break
end
end
if (j > 1+size(identidad,2))
j=j-size(identidad,2);
else
j=j+size(identidad,2);
end

fprintf(1,'X%d = %.1f \n',j-1,cuadro(1+n,end))

end
end
end

function [f]=factibilidad(cuadro,c)
%% verificar factibilidad

fact=cuadro(c+1:end,end) >= 0; % se analiza inv(B)*b

if fact % si el cuadro es factible

f=1;
else
% si el cuadro no es factible (existen elementos que pueden minimizar an la funcion
f=0;
end

function [d]=optimalidad(cuadro,m,c,fase)
%% verificar optimalidad

Opt=cuadro(1,c+m+1:end-1) <= 0; % si todos los componentes son menores o iguales a

cero el cuadro es factible
if fase == 2 || fase == 3
if Opt % la base es ptima
d=1;
else % si la base no es ptima (existen elementos que pueden minimizar an la funcin)
d=0;
end
else
d=0;
end

function [fase,f,c]=fases(cuadro)
if (cuadro(2,end) > 0.01)
fase=1;
else
fase=2;
end
if fase == 1
f=2;
c=2;
else
f=1;
c=1;
end
INFORME DE LABORATORIO DE OPTIMIZACION LINEAL
TEMA: METODO SIMPLEX DUAL
FECHA: 15/09/2016

Qu es?
El mtodo simplex dual se inicia con una solucin mejor que ptima y una
solucin bsica no factible. Las condiciones de optimalidad y factibilidad estn
diseadas para preservar la optimalidad de las soluciones bsicas a medida
que la solucin se mueve hacia la factibilidad.
Condicin dual de factibilidad. La variable de salida, xr, es la variable bsica
que tiene el valor ms negativo (los empates se rompen de forma arbitraria). Si
todas las variables bsicas son no negativas, el algoritmo se termina.1
Condicin dual de optimalidad. Dado que xr es la variable de salida, sea el
costo reducido de la variable no bsica xj, y arj el coeficiente de restriccin en
la fila xr y en la columna xj de la tabla. La variable de entrada es la variable no
bsica con arj , 0 que corresponde a:

Qu hace?
Para iniciar la programacin lineal ptima y no factible, se debe cumplir con
dos requisitos:
1. La funcin objetivo debe satisfacer la condicin de optimalidad del mtodo
simplex regular.
2. Todas las restricciones deben ser del tipo (<=).
Las desigualdades del tipo (>=) se convierten en (<=) al multiplicar ambos
lados de la desigualdad por 21. Si la PL incluye restricciones , la ecuacin se
puede reemplazar por dos desigualdades. La solucin inicial es no factible si al
menos uno de los lados derechos de las desigualdades es negativo.

Variables:

Codigo en Matlab
function x = dual_simplex(c,A,b,eps,x0)
% Resolver:- Max c^Tx sujeto a Ax = b, x >= 0
% Utilizando el mtodo dual simplex
% Se nos da una solucin bsica no degenerada x0
% x = dual_simplex(c,A,b,eps,x0)
% eps es una tolerancia adecuada, digamos 1e-3
[m,n] = size(A);
% Paso 0: - Inicializar B y N y tambin x_B y s_N
B = find(x0);
N = find(ones(n,1) - abs(sign(x0)));
xB = x0(B);
y = A(:,B)'\c(B);
sN = c(N)-A(:,N)'*y;
iter = 0;
while 1 == 1,
iter = iter + 1;
% Paso 1:- Comprobar optimalidad
% de lo contrario, encuentra la variable bsica que deja es x_{B(i)}
[xBmin,i] = min(xB);
if xBmin >= -eps,
fprintf('Hemos terminado \n');
fprintf('El Nmero de iteraciones es %d\n',iter);
x = zeros(n,1);
x(B) = xB;
fprintf('El valor objetivo ptimo es %f\n',c'*x);
return;
 end;
% Paso 2:- Actualizar la fila de pivote
e = zeros(m,1);
e(i) = 1;
e = e(:);
v = A(:,B)'\e;
w = A(:,N)'*v;
% Paso 3:- Hallar la variable no bsica de entrada x_{N(j)}
zz = find(w < -eps);
if (isempty(zz))
error('System is infeasible\n');
end
[t,ii] = min(sN(zz)./w(zz));
j = zz(ii(1));
% Paso 4:- Resolver Bd = a_{N(j)} para d
d = A(:,B)\A(:,N(j));
% Paso 5:- Actualizar la base y la solucin bsica x_B
% Actualizar tambin s_N
temp = B(i);
B(i) = N(j);
N(j) = temp;
theta = xB(i)/w(j);
xB = xB - theta*d;
xB(i) = theta;

sN = sN -t*w;
sN(j) = -t;
end; % while

INFORME DE LABORATORIO DE OPTIMIZACION LINEAL

TEMA: ASIGNACIONES
FECHA: 20/10/2016

Qu es?

El modelo de asignacin clsico se ocupa de compaginar a los trabajadores

(con diversas habilidades) con los trabajos. Presumiblemente, la variacin de la
habilidad afecta el costo de completar un trabajo. La meta es determinar la
asignacin de costo mnimo de los trabajadores a los trabajos. El elemento cij
representa el costo de asignar el trabajador i al trabajo j (i,j 5 1, 2,,n). No se
pierde la generalidad al suponer que la cantidad de trabajadores y la de los
trabajos son iguales, porque siempre podemos agregar trabajadores o trabajos
ficticios para satisfacer esta suposicin.

Qu hace?
Paso 1. Determine pi, el elemento de costo mnimo en la fila i de la matriz de
costos original, y rstelo de todos los elementos de la fila i, i 5 1, 2, 3.

Paso 2. Para la matriz creada en el paso 1, determine qj, el elemento de costo

mnimo de la columna j, y rstelo de todos los elementos de la columna j, j 5 1,
2, 3.

Paso 3. A partir de la matriz del paso 2, intente determinar una asignacin

factible entre todas las entradas cero resultantes.

3a. Si puede hallarse esa asignacin, es ptima.

3b. De lo contrario, se requieren ms clculos

Variables:

En el Cdigo se harn ms especificaciones

Codigo en Matlab
mcostos=AA % Matriz de costos
asignar = false(size(mcostos));
costo = 0;

mcostos(mcostos~=mcostos)=Inf;
vmat = mcostos<Inf;
vcol = any(vmat);
vfil = any(vmat,2);

nfil = sum(vfil);
ncol = sum(vcol);
n = max(nfil,ncol);
if ~n
return
end
dmat = zeros(n);
dmat(1:nfil,1:ncol) = mcostos(vfil,vcol);
% Paso 1: Restar el mnimo de fila, de cada fila.
dmat = bsxfun(@minus, dmat, min(dmat,[],2));

% Paso 2: Encontrar un cero de dmat. Si no hay ceros marcados en su

columna o fila, comienzan el cero. Repetir procedimiento para cada cero
zP = ~dmat;
starZ = false(n);
while any(zP(:))
[r,c]=find(zP,1);
starZ(r,c)=true;
zP(r,:)=false;
zP(:,c)=false;
end

while 1
% Paso 3: Cubrir cada columna con un cero estrellado. Si todas
% las columnas estn marcados entonces el tablero es mximo
primeZ = false(n);
cubrircol = any(starZ);
if ~any(~cubrircol)
break
end
cubrirfil = false(n,1);
while 1
% Paso 4: Encontrar un cero sin marca y prepararlo. Si no hay ningn
cero
% marcado en la fila que contiene este cero, ir al paso 5.
% De lo contrario, cubrir esta fila y descubrir la columna que
% contiene el cero marcado. Continuar de esta manera hasta que
% no queden al descubierto los ceros a la izquierda. Guardar el
% valor ms pequeo descubierto e ir al paso 6.

zP(:) = false;
zP(~cubrirfil,~cubrircol) = ~dmat(~cubrirfil,~cubrircol);
Paso = 6;
while any(any(zP(~cubrirfil,~cubrircol)))
[uZr,uZc] = find(zP,1);
primeZ(uZr,uZc) = true;
stz = starZ(uZr,:);
if ~any(stz)
Paso = 5;
break;
end
cubrirfil(uZr) = true;
cubrircol(stz) = false;
zP(uZr,:) = false;
zP(~cubrirfil,stz) = ~dmat(~cubrirfil,stz);
end
if Paso == 6

% Paso 6: Aadir el valor mnimo sin cubrir a todos los elementos de cada
fila cubiertos, y restarlo de todos los elementos de cada columna
descubierto.
% Volver al paso 4 sin alterar ningun marcado, primos, o lneas ubiertas.
M=dmat(~cubrirfil,~cubrircol);
minval=min(min(M));
 if minval==inf
return
end
dmat(cubrirfil,cubrircol)=dmat(cubrirfil,cubrircol)+minval;
dmat(~cubrirfil,~cubrircol)=M-minval;
else
break
end
end
% Paso 5: Construir una serie alternando preparados y ceros, de la
siguiente manera:
% Z0 representa el cero al descubierto encontrado en el paso 4.
% Z1 denota el cero participado en la columna de D0 (si existe).
% Z2 denota el cero imprimada en la fila de Z1 (siempre habr uno).
% Continuar hasta que la serie termina en un cero imprimado que no tiene
% favoritos cero en su columna. No destacar cada favoritos cero de la
serie,
% cada cero marcado de la serie, borrar todos los nmeros primos y
descubrir
% todas las lneas en la matriz. Volver al paso. 3

filZ1 = starZ(:,uZc);
starZ(uZr,uZc)=true;
while any(filZ1)
starZ(filZ1,uZc)=false;
uZc = primeZ(filZ1,:);
uZr = filZ1;
filZ1 = starZ(:,uZc);
starZ(uZr,uZc)=true;
end
end

% Costo de las Asignaciones

asignar(vfil,vcol) = starZ(1:nfil,1:ncol);
asignaciones=asignar.*mcostos
costo = sum(mcostos(asignar))
Ejecucion del Programa

INFORME DE LABORATORIO DE OPTIMIZACION LINEAL

TEMA: ALGORITMO DE FLOYD
FECHA: 05/01/2017

Qu es?
El algoritmo de Floyd es ms general que el de Dijkstra, porque determina la
ruta ms corta entre dos nodos cualesquiera de la red. El algoritmo representa
una red de n nodos como matriz cuadrada con n renglones y n columnas. El
elementos (i,j) de la matriz expresa la distancia d_ij del nodo i al nodo j, que es
finita si i est conectado directamente con j, e infinita en caso contrario.

El concepto de algoritmo de Floyd es directo. Dados tres nodos i,j y k en la

figura con las distancias entre si indicadas en los tres arcos, es ms corto ir a k
desde i pasando por j si

En este caso, lo ptimo es reemplazar la ruta directa de i j k. Este

intercambio de operacin triple se aplica en forma sistemtica a la red.

Qu hace?

Determina la ruta ms corta entre los nodos i y j con las matrices D_n y S_n con
las siguientes reglas:

En D_n, d_ij representa la distancia mas corta entre los nodos i y j.

En S_n, se determina el nodo intermedio k = s_ij que forme la ruta i k
j. Si s_ik = k y s_kj = j, detenerse; todos los nodos intermedios de la
ruta se han determinado. En caso contrario, repetir el procedimiento
entre los nodos i y k y entre los nodos k y j.

Variables:

P = guarda la matriz
n = tamao de la matriz
R = generacin de la matriz de recorridos
N= nmero de rotaciones
aa = variable auxiliar
P = visualiza ponderaciones
R = visualiza recorridos

Codigo en Matlab

% Implementacion del algoritmo de Floyd

% ==================================================================
% Antes de iniciar, guardar en a el valor infinito (a=inf)
% Guardar en A la matriz Ponderaciones
P=[
0 3 10 Inf Inf
3 0 Inf 5 Inf
10 Inf 0 6 15
Inf 5 6 0 4
Inf Inf Inf 4 0]
% Tamao de la matriz
n=max(size(P));
% Generacion de la Matriz de Recorridos
R=0;
for i=1:n
R(i:i,1:n)=1:1:n;
R(i,i)=0;
end
N=4; % Numero de Rotaciones
for l=1:N
for i=1:n % Evaluacion por nodo
i; % Visualizar numero de iteracion
for j=1:n % Fijar Columna
for k=1:n % Recorrer las filas
if (j~=k)&(i~=k)&(j~=i) % Evitar la diagonal
aa=P(k,i)+P(i,j); % Auxiliar
if aa<P(k,j) % La suma debe ser menor
P(k,j)=aa; % Auxiliar entra a P
R(k,j)=i; % Cambio en R
end
end
end
end
end
end
P % Visualizar Ponderaciones
R % Visualizar Recorridos

Ejecucin del Programa