http://lib.ulg.ac.be
http://matheo.ulg.ac.be
Models and algorithms for scheduling new orders
Auteur : Henrard, Lola
Promoteur(s) : Crama, Yves
Faculté : HEC-Ecole de gestion de l'ULg
Diplôme : Master en ingénieur de gestion, à finalité spécialisée en Supply Chain Management and
Business Analytics
Année académique : 2015-2016
URI/URL : http://hdl.handle.net/2268.2/1335
Avertissement à l'attention des usagers :
Tous les documents placés en accès ouvert sur le site le site MatheO sont protégés par le droit d'auteur. Conformément
aux principes énoncés par la "Budapest Open Access Initiative"(BOAI, 2002), l'utilisateur du site peut lire, télécharger,
copier, transmettre, imprimer, chercher ou faire un lien vers le texte intégral de ces documents, les disséquer pour les
indexer, s'en servir de données pour un logiciel, ou s'en servir à toute autre fin légale (ou prévue par la réglementation
relative au droit d'auteur). Toute utilisation du document à des fins commerciales est strictement interdite.
Par ailleurs, l'utilisateur s'engage à respecter les droits moraux de l'auteur, principalement le droit à l'intégrité de l'oeuvre
et le droit de paternité et ce dans toute utilisation que l'utilisateur entreprend. Ainsi, à titre d'exemple, lorsqu'il reproduira
un document par extrait ou dans son intégralité, l'utilisateur citera de manière complète les sources telles que
mentionnées ci-dessus. Toute utilisation non explicitement autorisée ci-avant (telle que par exemple, la modification du
document ou son résumé) nécessite l'autorisation préalable et expresse des auteurs ou de leurs ayants droit.
APPENDICES
A. APPENDIX A – CODIFICATION OF THE ALGORITM SOLVING
1 ∆!"# ! ∗ ≤ ! !!"#
A.1.
PARAMETERS SETTING
//Setting parameters
n0=6;
nN=3;
minP0=2;
minPN=2;
maxP0=10;
maxPN=10;
minMultP0=2*n0-1;
maxMultP0=2*n0+1;
minMultPN=2*nN-1;
maxMultPN=2*nN+1;
k=10;
DLN=1000;
[J0,JN]=ExampleCreation(n0,nN,minP0,minPN,maxP0,maxPN,minMultP0,minMultPN,m
axMultP0,maxMultPN);
disp(J0)
disp(JN)
[PiStar,EpsiStar]=EDDRules(J0,JN);
disp(PiStar)
disp(EpsiStar)
[Juxtaposition,MaxLatenessJuxtaposition,TotalCTJuxtaposition]=Juxtaposition
Creation(PiStar,EpsiStar);
disp(Juxtaposition)
disp(MaxLatenessJuxtaposition)
disp(TotalCTJuxtaposition)
[Sigma,MaxLatenessSigma,MaxDisruptionSigma,TotalCTSigma]=SigmaCreation(PiSt
ar,EpsiStar,n0,nN,k,DLN);
disp(Sigma)
disp(MaxLatenessSigma)
disp(MaxDisruptionSigma)
disp(TotalCTSigma)
[EDDSequence,MaxLatenessEDD,MaxDisruptionEDD,TotalCTEDD]=EDDSequenceCreatio
n(J0,JN,n0,nN,PiStar);
disp(EDDSequence)
disp(MaxLatenessEDD)
disp(MaxDisruptionEDD)
disp(TotalCTEDD)
V
A.2.
RANDOM EXAMPLE
// Creation of the example to be tested
function [J0, JN]=ExampleCreation(n0, nN, minP0, minPN, maxP0, maxPN,
minMultP0, minMultPN, maxMultP0, maxMultPN, DependentDD)
//// -> J0
i0=[1:n0];
P0=grand(1,n0,'unf',minP0,maxP0);
D0=[];
i=1;
while i<=n0
if DependentDD==1
MultD0i=grand(1,1,'unf',minMultP0,maxMultP0);
D0(1,$+1)=P0(1,i)*MultD0i;
else
D0(1,$+1)=grand(1,1,'unf',minMultP0,maxMultP0);
end
i=i+1;
end
J0=[i0;P0;D0];
//// -> JN
iN=[n0+1:n0+nN];
PN=grand(1,nN,'unf',minPN,maxPN);
DN=[];
i=1;
while i<=nN
if DependentDD==1
MultDNi=grand(1,1,'unf',minMultPN,maxMultPN);
DN(1,$+1)=PN(1,i)*MultDNi;
else
DN(1,$+1)=grand(1,1,'unf',minMultPN,maxMultPN);
end
i=i+1;
end
JN=[iN;PN;DN];
endfunction
A.3.
PISTAR AND EPSISTAR
//////////// EDD Rules
function [PiStar, EpsiStar]=EDDRules(J0, JN, n0, nN)
////////////PiStar
PiStar=[];
x=1;
Min={};
EDD=[];
while x<=n0
Min=min(J0(3,:));
y=1;
while y<=n0
if J0(3,y)==Min then
EDD=J0(:,y);
PiStar(:,$+1)=EDD;
J0(:,y)=[];
EDD=[];
y=n0+1;
else
y=y+1;
end
VI
end
x=x+1;
end
PiStar(:,1)=[];
C0=[];
x=1;
while x<=n0
C0(1,$+1)=C0(1,$)+PiStar(2,x);
x=x+1;
end
PiStar($+1,:)=C0;
////////////EpsiStar
EpsiStar=[];
x=1;
Min={};
EDD=[];
while x<=nN
Min=min(JN(3,:));
y=1;
while y<=nN
if JN(3,y)==Min then
EDD=JN(:,y);
EpsiStar(:,$+1)=EDD;
JN(:,y)=[];
EDD=[];
y=nN+1;
else
y=y+1;
end
end
x=x+1;
end
EpsiStar(:,1)=[];
CN=[];
x=1;
while x<=nN
CN(1,$+1)=CN(1,$)+EpsiStar(2,x);
x=x+1;
end
EpsiStar($+1,:)=CN;
endfunction
A.4.
JUXTAPOSITION
function [Juxtaposition, MaxLatenessJuxtaposition,
TotalCTJuxtaposition]=JuxtapositionCreation(PiStar, EpsiStar)
PiStar(5,:)=[];
PiStar(4,:)=[];
EpsiStar(5,:)=[];
EpsiStar(4,:)=[];
Juxtaposition=[PiStar EpsiStar];
CTJuxtaposition=[];
x=1;
n=length(Juxtaposition(1,:));
while x<=n
CTJuxtaposition(1,$+1)=CTJuxtaposition(1,$)+Juxtaposition(2,x);
x=x+1;
end
Juxtaposition($+1,:)=CTJuxtaposition(1,:);
LatenessJuxtaposition=[];
VII
x=1;
while x<=n
LatenessJuxtaposition(1,$+1)=Juxtaposition(4,x)-Juxtaposition(3,x);
x=x+1;
end
Juxtaposition($+1,:)=LatenessJuxtaposition(1,:);
MaxLatenessJuxtaposition=max(Juxtaposition(5,:));
TotalCTJuxtaposition=sum(Juxtaposition(4,:));
endfunction
A.5.
SIGMA
//Creation of the sequence Sigma
function [Sigma, MaxLatenessSigma, MaxDisruptionSigma,
TotalCTSigma]=SigmaCreation(PiStar, EpsiStar, n0, nN, k, DLN)
// Setting of the deadlines
DL0=PiStar(4,:)+k;
PiStar($+1,:)=DL0;
EpsiStar($+1,:)=DLN;
n=n0+nN;
x=n0;
y=nN;
Sigma=zeros(5,n);
while n>0
if x>0
lastjobJ0=PiStar(:,$);
CT0=PiStar(4,$);
end
if y>0
lastjobJN=EpsiStar(:,$);
CTN=EpsiStar(4,$);
end
CT=CT0+CTN;
if lastjobJ0(5,:)>=CT & lastjobJN(5,:)>=CT
M=[lastjobJ0 lastjobJN];
elseif lastjobJ0(5,:)>=CT
M=[lastjobJ0];
lastjobJN=[];
else
M=[lastjobJN];
lastjobJ0=[];
end
if max(M(3,:))==lastjobJ0(3,:)
Sigma(:,n)=lastjobJ0;
PiStar(:,$)=[];
x=x-1;
else
Sigma(:,n)=lastjobJN;
EpsiStar(:,$)=[];
y=y-1;
end
CT0=[];
CTN=[];
lastjobJ0=[];
lastjobJN=[];
M=[];
n=n-1;
end
////////////Completion time////////////
n=n0+nN;
VIII
i=1;
CT=[];
for i=1:n
CT(1,$+1)=CT(1,$)+Sigma(2,i);
i=i+1;
end
////////////Lateness////////////
for i=1:n
Lateness(1,$+1)=CT(1,i)-Sigma(3,i);
i=i+1;
end
////////////Disruption////////////
i=1;
Disruption=[];
for i=1:n
if Sigma(1,i)<=n0
Disruption(1,$+1)=CT(1,i)-Sigma(4,i);
else
Disruption(1,$+1)=0;
end
i=i+1;
end
////////////Assembling////////////
Sigma(4,:)=CT(1,:);
Sigma(5,:)=Lateness(1,:);
Sigma($+1,:)=Disruption(1,:);
MaxLatenessSigma=max(Sigma(5,:));
MaxDisruptionSigma=max(abs(Sigma(6,:)));
TotalCTSigma=sum(Sigma(4,:));
endfunction
A.6.
EDD SEQUENCE
//Creation of sequence EDD with both
function [EDDSequence, MaxLatenessEDD, MaxDisruptionEDD,
TotalCTEDD]=EDDSequenceCreation(J0, JN, n0, nN, PiStar)
EDDSequence=[];
J=[J0 JN];
x=1;
n=length(J(1,:));
Min={};
EDD=[];
while x<=n
Min=min(J(3,:));
y=1;
while y<=n
if J(3,y)==Min then
EDD=J(:,y);
EDDSequence(:,$+1)=EDD;
J(:,y)=[];
EDD=[];
y=n+1;
else
y=y+1
end
end
x=x+1
IX
end
EDDSequence(:,1)=[];
CTEDD=[];
x=1;
while x<=n
CTEDD(1,$+1)=CTEDD(1,$)+EDDSequence(2,x);
x=x+1;
end
EDDSequence($+1,:)=CTEDD;
LatenessEDD=[];
x=1;
while x<=n
LatenessEDD(1,$+1)=EDDSequence(4,x)-EDDSequence(3,x);
x=x+1;
end
EDDSequence($+1,:)=LatenessEDD(1,:);
DisruptionEDD=[];
x=1;
l=length(PiStar(1,:));
while x<=n
y=1;
if EDDSequence(1,x)<=n0
while y<=l
if EDDSequence(1,x)==PiStar(1,y)
DisruptionEDD(1,$+1)=EDDSequence(4,x)-PiStar(4,y);
y=l+1;
else
y=y+1;
end
end
else
DisruptionEDD(1,$+1)=0;
end
x=x+1;
end
EDDSequence($+1,:)=DisruptionEDD(1,:);
MaxLatenessEDD=max(EDDSequence(5,:));
MaxDisruptionEDD=max(abs(EDDSequence(6,:)));
TotalCTEDD=sum(EDDSequence(4,:));
endfunction
X
B. APPENDIX B – CODIFICATION OF THE ALGORITM SOLVING
1 ∆!"# ! ∗ ≤ ! !!
B.1.
PARAMETERS SETTING
//Setting parameters
n0=6;
nN=3;
minP0=2;
minPN=2;
maxP0=10;
maxPN=10;
minMultP0=2*n0-1;
maxMultP0=2*n0+1;
minMultPN=2*nN-1;
maxMultPN=2*nN+1;
k=10;
DLN=1000;
[J0,JN]=ExampleCreation(n0,nN,minP0,minPN,maxP0,maxPN,minMultP0,minMultPN,m
axMultP0,maxMultPN);
disp(J0)
disp(JN)
[PiStarSPT,EpsiStarSPT]=SPTRules(J0,JN,n0,nN);
disp(PiStarSPT)
disp(EpsiStarSPT)
[JuxtapositionSPT,MaxLatJuxtapositionSPT,TotalCTJuxtapositionSPT]=Juxtaposi
tionSPTCreation(PiStarSPT,EpsiStarSPT);
disp(JuxtapositionSPT)
disp(MaxLatJuxtapositionSPT)
disp(TotalCTJuxtapositionSPT)
[SigmaSPT,MaxLatenessSigmaSPT,MaxDisruptionSigmaSPT,TotalCTSigmaSPT]=SigmaS
PTCreation(PiStarSPT,EpsiStarSPT,n0,nN,k,DLN);
disp(SigmaSPT)
disp(MaxLatenessSigmaSPT)
disp(MaxDisruptionSigmaSPT)
disp(TotalCTSigmaSPT)
[SPTSequence,MaxLatenessSPT,MaxDisruptionSPT,TotalCTSPT]=SPTSequenceCreatio
n(J0,JN,n0,nN,PiStarSPT);
disp(SPTSequence)
disp(MaxLatenessSPT)
disp(MaxDisruptionSPT)
disp(TotalCTSPT)
XI
B.2.
RANDOM EXAMPLE
// Creation of the example to be tested
function [J0, JN]=ExampleCreation(n0, nN, minP0, minPN, maxP0, maxPN,
minMultP0, minMultPN, maxMultP0, maxMultPN, DependentDD)
//// -> J0
i0=[1:n0];
P0=grand(1,n0,'unf',minP0,maxP0);
D0=[];
i=1;
while i<=n0
if DependentDD==1
MultD0i=grand(1,1,'unf',minMultP0,maxMultP0);
D0(1,$+1)=P0(1,i)*MultD0i;
else
D0(1,$+1)=grand(1,1,'unf',minMultP0,maxMultP0);
end
i=i+1;
end
J0=[i0;P0;D0];
//// -> JN
iN=[n0+1:n0+nN];
PN=grand(1,nN,'unf',minPN,maxPN);
DN=[];
i=1;
while i<=nN
if DependentDD==1
MultDNi=grand(1,1,'unf',minMultPN,maxMultPN);
DN(1,$+1)=PN(1,i)*MultDNi;
else
DN(1,$+1)=grand(1,1,'unf',minMultPN,maxMultPN);
end
i=i+1;
end
JN=[iN;PN;DN];
endfunction
B.3.
PISTAR SPT AND EPSISTAR SPT
function [PiStarSPT, EpsiStarSPT]=SPTRules(J0, JN, n0, nN)
//PiStar
PiStarSPT=[];
x=1;
Min={};
SPT=[];
while x<=n0
Min=min(J0(2,:));
y=1;
while y<=n0
if J0(2,y)==Min then
SPT=J0(:,y);
PiStarSPT(:,$+1)=SPT;
J0(:,y)=[];
SPT=[];
y=n0+1;
else
y=y+1;
end
XII
end
x=x+1;
end
PiStarSPT(:,1)=[];
C0=[];
x=1;
while x<=n0
C0(1,$+1)=C0(1,$)+PiStarSPT(2,x);
x=x+1;
end
PiStarSPT($+1,:)=C0;
//JNStar
EpsiStarSPT=[];
x=1;
Min={};
SPT=[];
while x<=nN
Min=min(JN(2,:));
y=1;
while y<=nN
if JN(2,y)==Min then
SPT=JN(:,y);
EpsiStarSPT(:,$+1)=SPT;
JN(:,y)=[];
SPT=[];
y=nN+1;
else
y=y+1;
end
end
x=x+1;
end
EpsiStarSPT(:,1)=[];
CN=[];
x=1;
while x<=nN
CN(1,$+1)=CN(1,$)+EpsiStarSPT(2,x);
x=x+1;
end
EpsiStarSPT($+1,:)=CN;
endfunction
B.4.
JUXTAPOSITION SPT
function [JuxtapositionSPT, MaxLatJuxtapositionSPT,
TotalCTJuxtapositionSPT]=JuxtapositionSPTCreation(PiStarSPT, EpsiStarSPT)
PiStarSPT(5,:)=[];
PiStarSPT(4,:)=[];
EpsiStarSPT(5,:)=[];
EpsiStarSPT(4,:)=[];
JuxtapositionSPT=[PiStarSPT EpsiStarSPT];
CTJuxtapositionSPT=[];
x=1;
n=length(JuxtapositionSPT(1,:));
while x<=n
CTJuxtapositionSPT(1,$+1)=CTJuxtapositionSPT(1,$)+JuxtapositionSPT(2,x);
x=x+1;
end
XIII
JuxtapositionSPT($+1,:)=CTJuxtapositionSPT(1,:);
LatenessJuxtapositionSPT=[];
x=1;
while x<=n
LatenessJuxtapositionSPT(1,$+1)=JuxtapositionSPT(4,x)JuxtapositionSPT(3,x);
x=x+1;
end
JuxtapositionSPT($+1,:)=LatenessJuxtapositionSPT(1,:);
MaxLatJuxtapositionSPT=max(JuxtapositionSPT(5,:));
TotalCTJuxtapositionSPT=sum(JuxtapositionSPT(4,:));
endfunction
B.5.
SIGMA SPT
//Creation of the sequence SigmaSPT
function [SigmaSPT, MaxLatenessSigmaSPT, MaxDisruptionSigmaSPT,
TotalCTSigmaSPT]=SigmaSPTCreation(PiStarSPT, EpsiStarSPT, n0, nN, k, DLN)
// Setting of the deadlines
DL0=PiStarSPT(4,:)+k;
PiStarSPT($+1,:)=DL0;
EpsiStarSPT($+1,:)=DLN;
n=n0+nN;
x=n0;
y=nN;
SigmaSPT=zeros(5,n);
while n>0
if x>0
lastjobJ0=PiStarSPT(:,$)
CT0=PiStarSPT(4,$);
end
if y>0
lastjobJN=EpsiStarSPT(:,$)
CTN=EpsiStarSPT(4,$);
end
CT=CT0+CTN
if lastjobJ0(5,:)>=CT & lastjobJN(5,:)>=CT
M=[lastjobJ0 lastjobJN]
elseif lastjobJ0(5,:)>=CT
M=[lastjobJ0]
lastjobJN=[]
else
M=[lastjobJN]
lastjobJ0=[]
end
if max(M(2,:))==lastjobJ0(2,:)
SigmaSPT(:,n)=lastjobJ0
PiStarSPT(:,$)=[]
x=x-1;
else
SigmaSPT(:,n)=lastjobJN
EpsiStarSPT(:,$)=[]
y=y-1;
end
CT0=[];
CTN=[];
lastjobJ0=[];
lastjobJN=[];
M=[];
XIV
n=n-1;
end
////////////Completion time////////////
n=n0+nN;
i=1;
CT=[];
for i=1:n
CT(1,$+1)=CT(1,$)+SigmaSPT(2,i);
i=i+1;
end
////////////Latness////////////
for i=1:n
Lateness(1,$+1)=CT(1,i)-SigmaSPT(3,i);
i=i+1;
end
////////////Disruption////////////
i=1;
Disruption=[];
for i=1:n
if SigmaSPT(1,i)<=n0
Disruption(1,$+1)=CT(1,i)-SigmaSPT(4,i);
else
Disruption(1,$+1)=0;
end
i=i+1;
end
SigmaSPT(4,:)=CT(1,:);
SigmaSPT(5,:)=Lateness(1,:);
SigmaSPT($+1,:)=Disruption(1,:);
MaxLatenessSigmaSPT=max(SigmaSPT(5,:));
MaxDisruptionSigmaSPT=max(abs(SigmaSPT(6,:)));
TotalCTSigmaSPT=sum(SigmaSPT(4,:));
endfunction
B.6.
SPT SEQUENCE
//Creation of sequence SPT with both
function [SPTSequence, MaxLatenessSPT, MaxDisruptionSPT,
TotalCTSPT]=SPTSequenceCreation(J0, JN, n0, nN, PiStarSPT)
SPTSequence=[];
J=[J0 JN];
x=1;
n=length(J(1,:));
Min={};
SPT=[];
while x<=n
Min=min(J(2,:));
y=1;
while y<=n
if J(2,y)==Min then
SPT=J(:,y);
SPTSequence(:,$+1)=SPT ;
J(:,y)=[];
SPT=[];
y=n+1;
else
y=y+1
XV
end
end
x=x+1
end
SPTSequence(:,1)=[];
CTSPT=[];
x=1;
while x<=n
CTSPT(1,$+1)=CTSPT(1,$)+SPTSequence(2,x);
x=x+1;
end
SPTSequence($+1,:)=CTSPT;
LatenessSPT=[];
x=1;
while x<=n
LatenessSPT(1,$+1)=SPTSequence(4,x)-SPTSequence(3,x);
x=x+1;
end
SPTSequence($+1,:)=LatenessSPT(1,:);
DisruptionSPT=[];
x=1;
l=length(PiStarSPT(1,:));
while x<=n
y=1;
if SPTSequence(1,x)<=n0
while y<=l
if SPTSequence(1,x)==PiStarSPT(1,y)
DisruptionSPT(1,$+1)=SPTSequence(4,x)-PiStarSPT(4,y);
y=l+1;
else
y=y+1;
end
end
else
DisruptionSPT(1,$+1)=0;
end
x=x+1;
end
SPTSequence($+1,:)=DisruptionSPT(1,:);
MaxLatenessSPT=max(SPTSequence(5,:));
MaxDisruptionSPT=max(abs(SPTSequence(6,:)));
TotalCTSPT=sum(SPTSequence(4,:));
endfunction
XVI
C. APPENDIX C – PARAMETERS SETTING AFTER MODIFICATIONS
//////////////////////Setting parameters//////////////////////
RandSol=1;
Loop=1;
Randn=100;
k=10;
DLN=10000;
DependentDD=1;
while Randn<=200
disp(Randn)
if RandSol==0 then
sheets=readxls('\Users\lolahenrard\Desktop\HEC\M2\Mémoire\Mémoire\Example.x
ls');
OriginalJobs=sheets(1);
n0=OriginalJobs(1,:).value;
n0(1,1)=[];
P0=OriginalJobs(2,:).value;
P0(1,1)=[];
D0=OriginalJobs(3,:).value;
D0(1,1)=[];
J0=[n0;P0;D0];
n0=length(J0(1,:));
NewJobs=sheets(2);
nN=NewJobs(1,:).value;
nN(1,1)=[];
PN=NewJobs(2,:).value;
PN(1,1)=[];
DN=NewJobs(3,:).value;
DN(1,1)=[];
JN=[nN;PN;DN];
nN=length(JN(1,:));
else
n0=ceil(Randn);
nN=ceil(Randn);
minP0=2;
maxP0=10;
minPN=2;
maxPN=10;
minMultP0=(n0+nN-2);
maxMultP0=(n0+nN+2);
minMultPN=(n0+nN-2);
maxMultPN=(n0+nN+2);
[J0,JN]=ExampleCreation(n0,nN,minP0,minPN,maxP0,maxPN,minMultP0,minMultPN,m
axMultP0,maxMultPN,DependentDD);
end
////////////////////////////////Lmax////////////////////////////////
[PiStar,EpsiStar]=EDDRules(J0,JN);
DLN=ceil(PiStar(4,$))+ceil(EpsiStar(4,$));
MinTimeDisrA=floor(EpsiStar(4,1));
MaxTimeDisrA=ceil(EpsiStar(4,$));
k=MinTimeDisrA;
kA=[];
DisrA=[];
LmaxA=[];
TotCTA=[];
XVII
while k<=MaxTimeDisrA
[Sigma,MaxLatenessSigma,MaxDisruptionSigma,TotalCTSigma]=SigmaCreation(PiSt
ar,EpsiStar,n0,nN,k,DLN);
kA(1,$+1)=k;
DisrA(1,$+1)=MaxDisruptionSigma/Sigma(4,$)*100;
LmaxA(1,$+1)=MaxLatenessSigma/Sigma(4,$)*100;
TotCTA(1,$+1)=TotalCTSigma/(n0+nN)/Sigma(4,$)*100;
k=k+1;
end
if Loop==1
kA=kA/k;
end
subplot(2,4,1);
plot(kA,DisrA,"r");
plot(kA,LmaxA,"b");
plot(kA,TotCTA,"g");
xtitle("Graph","k","Values");
legend("Disruption","Lmax","CT",-6);
if Loop==1
set(gca(),"data_bounds",matrix([0,1,-100,100],2,-1));
else
set(gca(),"data_bounds",matrix([0,k,-100,100],2,-1));
end
subplot(2,4,2);
plot(DisrA,LmaxA,"b");
xtitle("Graph","Disruption","Lateness");
set(gca(),"data_bounds",matrix([0,100,-100,100],2,-1));
subplot(2,4,3);
plot(DisrA,TotCTA,"b");
xtitle("Graph","Disruption","Completion Time");
set(gca(),"data_bounds",matrix([0,100,0,100],2,-1));
subplot(2,4,4);
plot(TotCTA,LmaxA,"b");
xtitle("Graph","Completion Time","Lateness");
set(gca(),"data_bounds",matrix([0,100,-100,100],2,-1));
////////////////////////////////TotC////////////////////////////////
[PiStarSPT,EpsiStarSPT]=SPTRules(J0,JN,n0,nN);
DLN=ceil(PiStarSPT(4,$))+ceil(EpsiStarSPT(4,$));
MinTimeDisrB=floor(EpsiStarSPT(4,1));
MaxTimeDisrB=ceil(EpsiStarSPT(4,$));
kB=[];
DisrB=[];
LmaxB=[];
TotCTB=[];
k=MinTimeDisrB;
while k<=MaxTimeDisrB
[SigmaSPT,MaxLatenessSigmaSPT,MaxDisruptionSigmaSPT,TotalCTSigmaSPT]=SigmaS
PTCreation(PiStarSPT,EpsiStarSPT,n0,nN,k,DLN);
kB(1,$+1)=k;
DisrB(1,$+1)=MaxDisruptionSigmaSPT/SigmaSPT(4,$)*100;
LmaxB(1,$+1)=MaxLatenessSigmaSPT/SigmaSPT(4,$)*100;
TotCTB(1,$+1)=TotalCTSigmaSPT/(n0+nN)/SigmaSPT(4,$)*100;
k=k+1;
end
XVIII
if Loop==1
kB=kB/k;
end
subplot(2,4,5);
plot(kB,DisrB,"r");
plot(kB,LmaxB,"b");
plot(kB,TotCTB,"g");
xtitle("Graph","k","Values");
legend("Disruption","Lmax","CT",-6);
if Loop==1
set(gca(),"data_bounds",matrix([0,1,-100,100],2,-1));
else
set(gca(),"data_bounds",matrix([0,k,-100,100],2,-1));
end
subplot(2,4,6);
plot(DisrB,LmaxB,"b");
xtitle("Graph","Disruption","Lateness");
set(gca(),"data_bounds",matrix([0,100,-100,100],2,-1));
subplot(2,4,7);
plot(DisrB,TotCTB,"b");
xtitle("Graph","Disruption","Completion Time");
set(gca(),"data_bounds",matrix([0,100,0,100],2,-1));
subplot(2,4,8);
plot(TotCTB,LmaxB,"b");
xtitle("Graph","Completion Time","Lateness");
set(gca(),"data_bounds",matrix([0,100,-100,100],2,-1));
if Loop==1
else
break
end
Randn=Randn+10;
end
x=0;
disp(x)
XIX
D. APPENDIX D – RESULTS REPRESENTED THROUGH GRAPHS
D.1.
PROCESSING
TIMES AND DUE DATES FROM THE SAME VALUE RANGES
AND DEPENDENT
D.1.1. BETWEEN 2 AND 20 JOBS PER SET (INCREASE BY 2)
It is compared the efficient schedules of ten different examples. For each example the number
of initial and new jobs are identical. The first example contains 2 jobs in J0 and 2 jobs in JN.
In the second example there are 4 jobs in each set. The number of jobs in each set is increased
by 2 until there are 20 jobs in each.
The first four graphs represent the results obtained by applying the first algorithm, the one
solving 1 ∆!"# π∗ ≤ k L!!" . The four following graphs are obtained by implementing
the algorithm solving the case 1 ∆!"# π∗ ≤ k
!! . The graph 1 and 5 display the
performances of the three parameters (percentage of maximum lateness, percentage of mean
completion time and percentage of maximum disruption) over the progress of the creation of
the schedules. The graphs 2 and 6 represent the trade-off between the percentage of maximum
lateness (y-axis) and the percentage of maximum time disruption (x-axis). The graphs 3 and 7
embodies the relation between the percentage of mean completion time (y-axis) and the
percentage of maximum disruption (x-axis). Finally the graphs 4 and 8 characterize the
combined performance of the schedules on the percentage of maximum lateness (y-axis) and
the percentage of mean completion time (x-axis).
XX
D.1.2. BETWEEN 100 AND 200 JOBS PER SET (INCREASE BY 10)
D.1.3. BETWEEN 200 AND 1000 JOBS PER SET (INCREASE BY 100)
In the graphs below, the examples used all have between 100 and 200 jobs in J0 and JN.
XXI
D.2.
PROCESSING
TIMES AND DUE DATES FROM THE SAME VALUE RANGES
AND INDEPENDENT
D.3.
PROCESSING TIMES FROM THE DIFFERENT VALUE RANGES
D.3.1. PROCESSING TIMES HIGHER FOR THE NEW ORDERS
XXII
D.3.2. PROCESSING TIMES HIGHER FOR THE ORIGINAL ORDERS
D.4.
DUE DATES FROM DIFFERENT VALUE RANGES
D.4.1. DUE DATES HIGHER FOR THE NEW ORDERS
XXIII
D.4.2. DUE DATES HIGHER FOR THE ORIGINAL ORDERS
XXIV
BIBLIOGRAPHY
Akkan, C. (2015). Improving schedule stability in single-machine rescheduling for new
operation insertion. Computers & Operations Research, 64, 198–209
Baudin,
M.
(2010).
Introduction to Scilab.
Retrieved
March
14,
2016,
from
https://www.scilab.org/fr/resources/documentation/tutorials.
Blazewicz, J., Ecker, K. H., Pesch, E., Schmidt, G. & Weglarz, J. (2007). Handbook on
Scheduling: From Theory to Applications. Heidelberg: Springer.
Bovet, D. P. & Crescenzi, P. (1994). Introduction to the Theory of Complexity. New Jersey:
Prentice-Hall, Englewood Cliffs.
Brucker, P. (2007). Scheduling Algorithms. Heidelberg: Springer.
Chhajed, D & Lowe, T. J. (2008). Building Intuition: Insights From Basic Operations
Management Models and Principles. New York: Springer.
Christine, G. & Scilab Entreprise. (2013). Scilab pour les vrais debutants. Retrieved March
14, 2016, from https://www.scilab.org/fr/resources/documentation/tutorials.
Conway, R. W., Maxwell, L. W. & Miller, L. W. (1967). Theory of Scheduling. Mineola:
Addison-Wesley.
Graham, R. L., Lawler, E. L., Lenstra, J. K. & Rinnooy Kan, A. H. G. (1979). Optimization
and approximation in deterministic machine scheduling: A survey. Annals of Discrete
Mathematics, 5, 287 – 326.
Khodabakhshi, M., Hosseinzadeh Lotfi, F., Zhang, X., Li, S., Nasseri, S. H., Aryavash, K.,
& Tavakkoli-Moghaddam, R. (2013). Operational Research. Journal of Applied
Mathematics, 2013.
Koulamas, C. & Kyparisis, G. J. (2001). Single machine scheduling with release times,
deadlines and tardiness objectives. European Journal Of Operational Research, 133,
447–453.
XXV
Hall, N.G. & Potts, C.N. (2004). Rescheduling for new orders. Operations Research, 52, 3,
440–453.
H. Hoogeveen, H., Lenté, C. & T’kindt, V. (2012). Rescheduling for new orders on a single
machine with setup times. European Journal Of Operational Research, 223, 40–46.
Pinedo, M. (1995). Scheduling: Theory, Algorithms and Systems. New York: Springer.
Teghem, J. & Tuyttens, D. (2013). A bi-objective approach to reschedule new jobs in ones
machine model. International Transactions In Operations Research, 21, 871-898.
Vieira, G. E, Herrmann, J. W. & Lin, E. (2003). Rescheduling manufacturing systems: a
framework of strategies, policies, and methods. Journal of Scheduling, 6, 39-62.
(n.d.). Retrieved May 5, 2016, from www.britannica.com
XXVI
LIST OF FIGURES
Figure 3.1. Algorithm (DT) solving 1djLmax (Koulamas and Kyparisis, 2001, p.449) ......... 15
Figure 3.2. Algorithm solving 1|∆max π ∗≤ k|Lmax ............................................................. 18
Figure 3.3. Supposed algorithm of Smith (1956) solving 1djCj .............................................. 26
Figure 3.4. Algorithm solving 1|∆max π ∗≤ k|∑Cj ................................................................ 27
Figure 3.5. Percentage of maximum lateness .......................................................................... 34
Figure 3.6. Percentage of maximum time disruption ............................................................... 34
Figure 3.7. Percentage of mean completion time .................................................................... 35
Figure 3.8. Efficient schedules for the situation 1|∆max π ∗≤ k|LMax ................................. 38
Figure 3.9. Efficient schedules for the situation 1|∆max π ∗≤ k|∑Cj .................................... 38
XXVII
LIST OF TABLES
Table 2.1. Scheduling problems considered by Hall and Potts (2004) .................................... 10
Table 3.1. Matrix J0 created randomly .................................................................................... 21
Table 3.2. Matrix JN created randomly ................................................................................... 21
Table 3.3. Matrix PiStar ........................................................................................................... 21
Table 3.4. Matrix EpsiStar ....................................................................................................... 22
Table 3.5. Matrix Juxtaposition ............................................................................................... 22
Table 3.6. Matrix Sigma .......................................................................................................... 23
Table 3.7. Matrix EDD Sequence ............................................................................................ 23
Table 3.8. Comparison of the maximum lateness and the maximum time disruption for
different matrices ............................................................................................................. 24
Table 3.9. Matrix J0 created randomly .................................................................................... 29
Table 3.10. Matrix JN created randomly ................................................................................. 29
Table 3.11. Matrix PiStar SPT ................................................................................................. 29
Table 3.12. Matrix EpsiStar SPT ............................................................................................. 30
Table 3.13. Matrix Juxtaposition SPT ..................................................................................... 30
Table 3.14. Matrix Sigma SPT ................................................................................................ 31
Table 3.15. Matrix SPT Sequence ........................................................................................... 31
Table 3.16. Comparison of the total completion time and the maximum time disruption for
different matrices ............................................................................................................. 32
Table 3.17. Comparison of the maximum lateness and the maximum time disruption for
different matrices (in %) .................................................................................................. 35
Table 3.18. Comparison of the total completion time and the maximum time disruption for
different matrices (in %) .................................................................................................. 35
XXVIII
CONTENTS
Acknowledgments....................................................................................................................... I
Summary .................................................................................................................................. III
1. Introduction ......................................................................................................................... 1
1.1. Presentation of the topic .............................................................................................. 1
1.2. Personal motivation ..................................................................................................... 1
1.3. Objective ..................................................................................................................... 2
1.4. Structure of the work ................................................................................................... 2
2. Literature review ................................................................................................................. 3
2.1. Scheduling ................................................................................................................... 3
2.2. Rescheduling ............................................................................................................... 4
2.3. Hall and Potts .............................................................................................................. 5
2.3.1. Contextualisation ................................................................................................. 6
2.3.2. Objective function ............................................................................................... 7
2.3.3. Disruption ............................................................................................................ 8
2.3.4. Models overview ................................................................................................. 9
2.3.5. Computational complexity ................................................................................ 10
2.4. Additional readings ................................................................................................... 11
3. Methods............................................................................................................................. 13
3.1. Algorithm solving the scheduling problem
1∆!"# ! ∗≤ !"#$%. ....................... 13
3.1.1. (EDD,EDD) property ........................................................................................ 14
3.1.2. Algorithm of Koulamas and Kyparisis .............................................................. 14
3.1.3. Algorithm explanation ....................................................................................... 16
3.1.4. More direct approaches ..................................................................................... 19
3.1.5. Computation on scilab ....................................................................................... 20
3.2. Algorithm solving the scheduling problem
1∆!!" ! ∗≤ !"#. ............................. 24
3.2.1. (SPT,SPT) property ........................................................................................... 25
3.2.2. Algorithm of Smith............................................................................................ 25
3.2.3. Algorithm explanation ....................................................................................... 26
3.2.4. More direct approaches ..................................................................................... 28
3.2.5. Computation on Scilab ...................................................................................... 28
3.3. Programming improvement ...................................................................................... 33
XXIX
3.3.1. System of measure ............................................................................................. 33
3.3.2. Set of possible solutions .................................................................................... 36
4. Results ............................................................................................................................... 41
4.1. Tests .......................................................................................................................... 41
4.1.1. Adaptation of the programming ........................................................................ 41
4.1.2. Tests on the parameters ..................................................................................... 42
4.2. Analyses of the results .............................................................................................. 42
4.2.1. Processing times and due dates from common value ranges ............................ 43
4.2.2. Processing times from different value ranges ................................................... 44
4.2.3. Due dates from different value ranges............................................................... 45
4.3. General trends ........................................................................................................... 45
5. Conclusion ........................................................................................................................ 47
5.1. Subject and results summary ..................................................................................... 47
5.2. Criticisms and recommandations .............................................................................. 47
Appendices .................................................................................................................................V
A. Appendix A – Codification of the algoritm solving 1∆!"# ! ∗≤ !"#$% ..................V
A.1. Parameters setting ..................................................................................................V
A.2. Random example ................................................................................................. VI
A.3. PiStar and EpsiStar .............................................................................................. VI
A.4. Juxtaposition ....................................................................................................... VII
A.5. Sigma .................................................................................................................VIII
A.6. EDD Sequence ..................................................................................................... IX
B. Appendix B – Codification of the algoritm solving 1∆!"# ! ∗≤ !"# ...................... XI
B.1. Parameters setting ................................................................................................ XI
B.2. Random example ................................................................................................ XII
B.3. PiStar SPT and EpsiStar SPT.............................................................................. XII
B.4. Juxtaposition SPT ..............................................................................................XIII
B.5. Sigma SPT ........................................................................................................ XIV
B.6. SPT Sequence .....................................................................................................XV
C. Appendix C – Parameters setting after modifications ............................................. XVII
D. Appendix D – Results represented through graphs ....................................................XX
D.1. Processing times and due dates from the same value ranges and dependent .....XX
D.2. Processing times and due dates from the same value ranges and independentXXII
XXX
D.3. Processing times from the different value ranges ............................................ XXII
D.4. Due dates from different value ranges ............................................................XXIII
Bibliography ........................................................................................................................ XXV
List of figures .................................................................................................................... XXVII
List of Tables ................................................................................................................... XXVIII
Executive summary ................................................................................................................. VII
XXXI
EXECUTIVE SUMMARY
In order to efficiently manage their production processes, manufacturing companies schedule
their operations. Based on this schedule, a resources allocation planning is established and
promises are made to the customers concerning the delivery dates. However, unexpected
events might occur, making this schedule obsolete. The arrival of new orders forces planners
to reschedule. The new planning should minimize operating costs while avoiding disturbing
the initial schedule too much. Disruptions create disarray in the resources allocation planning
and dissatisfaction among the customers.
Hall and Potts (2004) analyse the rescheduling issue in a single machine environment. Two
algorithms proposed in their article are studied. They both aim at controlling the maximum
time disruption undergone by the jobs initially planned. The time disruption corresponds to
the difference between the original planned completion time of a job and the time at which the
job is supposed to be completed on the new schedule. The difference between the algorithms
is the operating cost they try to minimize. The first focuses on minimizing the maximum
lateness while the second on minimizing the total completion time.
The algorithms and the steps required to optimally reschedule a series of jobs is presented.
The procedure depicted is translated in computer language and computed in the program
Scilab. The resulting programming is used to realise tests and analyse the behaviour of the
algorithms. Two major aspects are important to underline. Firstly, both algorithms clearly
emphasize the trade-off between minimizing the operating cost of all jobs and controlling the
amount of disruptions. Secondly, when the processing times and the due dates of the orders
are linked, then using one method or the other is equivalent. In other cases, the choice
between both algorithms depends on the preferences of the companies.
The interest of researchers in rescheduling has been growing over the past few years. The
progresses are significant. This thesis aims at bringing a more practical point of view on the
subject and observes how two algorithms process in concrete terms. Improvements are still
needed in order to account for the complexity of the manufacturing industry environment and
of the rescheduling issue.