LAMPIRAN

Listing Program MATLAB untuk pemodelan penyakit Hepatits B dengan

kontrol optimal

function dy = optimalkontrol(~)
% Parameters of the model
b = 0.0121; epsilon = 0.016;
alpha = 0.16; y = 0.0969075;
beta = 0.95; k = 0.0000684 ; mu = 0.002;
theta = 0.1; eta = 0.00125925;
m = 0.00693;

% Parameters of the Runge-Kutta (4th order) method

test = -1; deltaError = 0.001; M = 1000; T=5;
t = linspace(0,T,M+1);
h = T / M; h2 = h / 2; h6 = h / 6;
S = zeros(1,M+1); E = zeros(1,M+1);
I = zeros(1,M+1); L = zeros(1,M+1);
R = zeros(1,M+1); V = zeros(1,M+1);

% Initial conditions of the model

S(1) =100; E(1) = 90; I(1) = 80; L(1) = 70; R(1) = 50; V(1) = 40;
%Vectors for system restrictions and control
Lambda1 = zeros(1,M+1); Lambda2 = zeros(1,M+1);
Lambda3 = zeros(1,M+1); Lambda4 = zeros(1,M+1);
Lambda5 = zeros(1,M+1); Lambda6 = zeros(1,M+1);

A = zeros(1,M+1);
W = zeros(1,M+1);
P = zeros(1,M+1);
C = zeros(1,M+1);
% Iterations of the method
while(test < 0)
oldS = S; oldE = E; oldI = I; oldL = L; oldR = R; oldV = V;
oldLambda1 = Lambda1; oldLambda2 = Lambda2;
oldLambda3 = Lambda3; oldLambda4 = Lambda4;
oldLambda5 = Lambda5; oldLambda6 = Lambda6;
oldA = A; oldW = W; oldP = P; oldC = C;
%Forward Runge-Kutta iterations
for i = 1:M
% Differential equations of the model

% First Runge-Kutta parameter

auxA = A(i);
auxW = W(i);
auxP = P(i);

143
auxC = C(i);
aux3 = beta*I(i)*S(i);
aux4 = alpha*beta*L(i)*S(i);

auxV1 = auxC*S(i) - theta*V(i) - m*V(i);

auxS1 = b - (aux3+aux4)*(1-auxA) + theta*V(i) - auxC*S(i) - m*S(i);
auxE1 = (aux3+aux4)*(1-auxA)- epsilon*E(i) - m*E(i);
auxI1 = epsilon*E(i) - y*I(i) - eta*I(i) - auxW*I(i) - m*I(i);
auxL1 = y*I(i) - k*L(i) - auxP*L(i) - m*L(i) - mu*L(i);
auxR1 = eta*I(i) + k*L(i) + auxW*I(i) + auxP*L(i) - m*R(i) ;

% Second Runge-Kutta parameter

auxA1 = 0.5*(A(i) + A(i+1));
auxW1 = 0.5*(W(i) + W(i+1));
auxP1 = 0.5*(P(i) + P(i+1));
auxC1 = 0.5*(C(i) + C(i+1));
auxSa = S(i) + h2 * auxS1; auxEa = E(i) + h2 * auxE1;
auxIa = I(i) + h2 * auxI1; auxLa = L(i) + h2 * auxL1;
auxRa = R(i) + h2 * auxR1; auxVa = V(i) + h2 * auxV1;

aux3a = beta*auxIa*auxSa;
aux4a = alpha*beta*auxLa*auxSa;

auxV2 = auxC1*auxSa - theta*auxVa - m*auxVa;

auxS2 = b - (aux3a+aux4a)*(1-auxA1) + theta*auxVa - auxC1*auxSa -
m*auxSa;
auxE2 = (aux3a+aux4a)*(1-auxA1) - epsilon*auxEa - m*auxEa;
auxI2 = epsilon*auxEa - y*auxIa - eta*auxIa - auxW1*auxIa - m*auxIa;
auxL2 = y*auxIa - k*auxLa - auxP1*auxLa - m*auxLa - mu*auxLa;
auxR2 = eta*auxIa + k*auxLa + auxW1*auxIa + auxP1*auxLa - m*auxRa ;

% Third Runge-Kutta parameter

auxSb = S(i) + h2 * auxS2; auxEb = E(i) + h2 * auxE2;
auxIb = I(i) + h2 * auxI2; auxLb = L(i) + h2 * auxL2;
auxRb = R(i) + h2 * auxR2; auxVb = V(i) + h2 * auxV2;

aux3b = beta*auxIb* auxSb;

aux4b = alpha*beta*auxLb*auxSb;

auxV3 = auxC1*auxSb - theta*auxVb - m*auxVb;

auxS3 = b - (aux3b+aux4b)*(1-auxA1) + theta*auxVb - auxC1*auxSb -
m*auxSb;
auxE3 = (aux3b+aux4b)*(1-auxA1) - epsilon*auxEb - m*auxEb;
auxI3 = epsilon*auxEb - y*auxIb - eta*auxIb - auxW1*auxIb - m*auxIb;
auxL3 = y*auxIb - k*auxLb - auxP1*auxLb - m*auxLb - mu*auxLb;
auxR3 = eta*auxIb + k*auxLb + auxW1*auxIb + auxP1*auxLb - m*auxRb ;

% Fourth Runge-Kutta parameter

auxSc = S(i) + h2 * auxS3; auxEc = E(i) + h2 * auxE3;
auxIc = I(i) + h2 * auxI3; auxLc = L(i) + h2 * auxL3;
auxRc = R(i) + h2 * auxR3; auxVc = V(i) + h2 * auxV3;

144
auxA2 = A(i+1);
auxW2 = W(i+1);
auxP2 = P(i+1);
auxC2 = C(i+1);
aux3c = beta*auxIc*auxSc;
aux4c = alpha*beta*auxLc*auxSc;

auxV4 = auxC2*auxSc - theta*auxVc - m*auxVc;

auxS4 = b - (aux3c+aux4c)*(1-auxA2)+ theta*auxVc - auxC2*auxSc -
m*auxSc;
auxE4 = (aux3c+aux4c)*(1-auxA2) - epsilon*auxEc - m*auxEc;
auxI4 = epsilon*auxEc - y*auxIc - eta*auxIc - auxW2*auxIc - m*auxIc;
auxL4 = y*auxIc - k*auxLc - auxP2*auxLc - m*auxLc - mu*auxLc;
auxR4 = eta*auxIc + k*auxLc + auxW2*auxIc + auxP2*auxLc - m*auxRc ;

% Runge-Kutta new approximation

S(i+1) = S(i) + h6 * (auxS1 + 2 * (auxS2 + auxS3) + auxS4);
E(i+1) = E(i) + h6 * (auxE1 + 2 * (auxE2 + auxE3) + auxE4);
I(i+1) = I(i) + h6 * (auxI1 + 2 * (auxI2 + auxI3) + auxI4);
L(i+1) = L(i) + h6 * (auxL1 + 2 * (auxL2 + auxL3) + auxL4);
R(i+1) = R(i) + h6 * (auxR1 + 2 * (auxR2 + auxR3) + auxR4);
V(i+1) = V(i) + h6 * (auxV1 + 2 * (auxV2 + auxV3) + auxV4);

end

%Backward Runge-Kutta iterations

for i = 1:M
j = M + 2 - i;
% Differential equations of the model
% First Runge-Kutta parameter

auxA3 = A(j);
auxW3 = W(j);
auxP3 = P(j);
auxC3 = C(j);

auxLambda11 = Lambda1(j)*(m + theta) - Lambda2(j)*theta;

auxLambda21 = (alpha*L(i)+I(i))*(Lambda3(j)-Lambda2(j))*(auxA3-
1)*beta + Lambda2(j)*(auxC3+m) - Lambda1(j)*auxC3 ;
auxLambda31 = Lambda3(j)*(m+epsilon) - Lambda4(j)*epsilon;
auxLambda41 = -0.04 + Lambda4(j)*(auxW3+y+m+eta) + beta*S(i)*(auxA3-
1)*(Lambda3(j)-Lambda2(j)) - Lambda5(j)*y - Lambda6(j)*(auxW3+eta);
auxLambda51 = -0.05 + (auxP3+k+m+mu)*Lambda5(j) -
Lambda6(j)*(auxP3+k) - alpha*S(i)*beta*(auxA3-1)*(Lambda2(j)-
Lambda3(j));
auxLambda61 = Lambda6(j)*m;

% Second Runge-Kutta parameter

auxA4 = 0.5*(A(j) + A(j-1));

auxW4 = 0.5*(W(j) + W(j-1));
auxP4 = 0.5*(P(j) + P(j-1));
auxC4 = 0.5*(C(j) + C(j-1));

145
auxVd = 0.5*(V(j) + V(j-1));
auxSd = 0.5*(S(j) + S(j-1));
auxEd = 0.5*(E(j) + E(j-1));
auxId = 0.5*(I(j) + I(j-1));
auxLd = 0.5*(L(j) + L(j-1));
auxRd = 0.5*(R(j) + R(j-1));

auxLambda1 = Lambda1(j) - h2 * auxLambda11;

auxLambda2 = Lambda2(j) - h2 * auxLambda21;
auxLambda3 = Lambda3(j) - h2 * auxLambda31;
auxLambda4 = Lambda4(j) - h2 * auxLambda41;
auxLambda5 = Lambda5(j) - h2 * auxLambda51;
auxLambda6 = Lambda6(j) - h2 * auxLambda61;

auxLambda12 = auxLambda1*(m + theta) - auxLambda2*theta;

auxLambda22 = (alpha*auxLd+auxId)*(auxLambda3-auxLambda2)*(auxA4-
1)*beta + auxLambda2*(auxC4+m) - auxLambda1*auxC4 ;
auxLambda32 = auxLambda3*(m+epsilon) - auxLambda4*epsilon;
auxLambda42 = -0.04 + auxLambda4*(auxW4+y+m+eta) +
beta*auxSd*(auxA4-1)*(auxLambda3-auxLambda2) - auxLambda5*y -
auxLambda6*(auxW4+eta);
auxLambda52 = -0.05 + (auxP4+k+m+mu)*auxLambda5 -
auxLambda6*(auxP4+k) - alpha*auxSd*beta*(auxA4-1)*(auxLambda2-
auxLambda3);
auxLambda62 = auxLambda6*m;

% Third Runge-Kutta parameter

auxLambda1a = Lambda1(j) - h2 * auxLambda12;
auxLambda2a = Lambda2(j) - h2 * auxLambda22;
auxLambda3a = Lambda3(j) - h2 * auxLambda32;
auxLambda4a = Lambda4(j) - h2 * auxLambda42;
auxLambda5a = Lambda5(j) - h2 * auxLambda52;
auxLambda6a = Lambda6(j) - h2 * auxLambda62;

auxLambda13 = auxLambda1a*(m+theta) - auxLambda2a*theta;

auxLambda23 = (alpha*auxLd+auxId)*(auxLambda3a-auxLambda2a)*(auxA4-
1)*beta + auxLambda2a*(auxC4+m) - auxLambda1a*auxC4 ;
auxLambda33 = auxLambda3a*(m+epsilon) - auxLambda4a*epsilon;
auxLambda43 = -0.04 + auxLambda4a*(auxW4+y+m+eta) +
beta*auxSd*(auxA4-1)*(auxLambda3a-auxLambda2a) - auxLambda5a*y -
auxLambda6a*(auxW4+eta);
auxLambda53 = -0.05 + (auxP4+k+m+mu)*auxLambda5a -
auxLambda6a*(auxP4+k) - alpha*auxSd*beta*(auxA4-1)*(auxLambda2a-
auxLambda3a);
auxLambda63 = auxLambda6a*m;

% Fourth Runge-Kutta parameter

auxA5 = 0.5*(A(j) + A(j-1));

auxW5 = 0.5*(W(j) + W(j-1));
auxP5 = 0.5*(P(j) + P(j-1));
auxC5 = 0.5*(C(j) + C(j-1));

146
auxVe = V(j-1);
auxSe = S(j-1);
auxEe = E(j-1);
auxIe = I(j-1);
auxLe = L(j-1);
auxRe = R(j-1);

auxLambda1b = Lambda1(j) - h * auxLambda13;

auxLambda2b = Lambda2(j) - h * auxLambda23;
auxLambda3b = Lambda3(j) - h * auxLambda33;
auxLambda4b = Lambda4(j) - h * auxLambda43;
auxLambda5b = Lambda5(j) - h * auxLambda53;
auxLambda6b = Lambda6(j) - h * auxLambda63;

auxLambda14 = auxLambda1b*(m+theta) - auxLambda2b*theta;

auxLambda24 = (alpha*auxLe+auxIe)*(auxLambda3b-auxLambda2b)*(auxA5-
1)*beta + auxLambda2b*(auxC5+m) - auxLambda1b*auxC5 ;
auxLambda34 = auxLambda3b*(m+epsilon) - auxLambda4b*epsilon;
auxLambda44 = -0.04 + auxLambda4b*(auxW5+y+m+eta) +
beta*auxSe*(auxA5-1)*(auxLambda3b-auxLambda2b) - auxLambda5b*y -
auxLambda6b*(auxW5+eta);
auxLambda54 = -0.05 + (auxP5+k+m+mu)*auxLambda5b -
auxLambda6b*(auxP5+k) - alpha*auxSe*beta*(auxA5-1)*(auxLambda2b-
auxLambda3b);
auxLambda64 = auxLambda6b*m;

% Runge-Kutta new approximation

Lambda1(j-1) = Lambda1(j) - h6 * (auxLambda11 + ...
+ 2 * (auxLambda12 + auxLambda13) + auxLambda14);
Lambda2(j-1) = Lambda2(j) - h6 * (auxLambda21 + ...
+ 2 * (auxLambda22 + auxLambda23) + auxLambda24);
Lambda3(j-1) = Lambda3(j) - h6 * (auxLambda31 + ...
+ 2 * (auxLambda32 + auxLambda33) + auxLambda34);
Lambda4(j-1) = Lambda4(j) - h6 * (auxLambda41 + ...
+ 2 * (auxLambda42 + auxLambda43) + auxLambda44);
Lambda5(j-1) = Lambda5(j) - h6 * (auxLambda51 + ...
+ 2 * (auxLambda52 + auxLambda53) + auxLambda54);
Lambda6(j-1) = Lambda6(j) - h6 * (auxLambda61 + ...
+ 2 * (auxLambda62 + auxLambda63) + auxLambda64);

end
% New vector control
for i = 1:M+1

waux(i) = Lambda3(i)*(beta*S(i)*I(i)+ alpha*beta*S(i)*L(i)) -

Lambda2(i)*(beta*S(i)*I(i)+ alpha*beta*S(i)*L(i));
auxA7 = min([1 max([0 waux(i)])]);
A(i) = 0.5*(auxA7 + oldA(i));

vaux(i) = I(i) * (Lambda4(i) - Lambda6(i));

auxW7 = min([1 max([0 vaux(i)])]);
W(i) = 0.5*(auxW7 + oldW(i));

147
haux(i) = L(i) * (Lambda5(i) - Lambda6(i))*(1/2.7);
auxP7 = min([1 max([0 haux(i)])]);
P(i) = 0.5*(auxP7 + oldP(i));

caux(i) = S(i) * (Lambda2(i) - Lambda1(i))*(1/1.5);

auxC7 = min([1 max([0 caux(i)])]);
C(i) = 0.5*(auxC7 + oldC(i));
end

for i = 1:M+1
J(i) = sum ((I.*0.04 + L.*0.05 + 0.75.*A.^2 + 1.35.*C.^2 + 0.5.*W.^2
+ 0.5.*P.^2 ));

end

% Absolute error for convergence

temp1 = deltaError * sum(abs(V)) - sum(abs(oldV - V));
temp2 = deltaError * sum(abs(S)) - sum(abs(oldS - S));
temp3 = deltaError * sum(abs(E)) - sum(abs(oldE - E));
temp4 = deltaError * sum(abs(I)) - sum(abs(oldI - I));
temp5 = deltaError * sum(abs(L)) - sum(abs(oldL - L));
temp6 = deltaError * sum(abs(R)) - sum(abs(oldR - R));
temp7 = deltaError * sum(abs(A)) - sum(abs(oldA - A));
temp8 = deltaError * sum(abs(W)) - sum(abs(oldW - W));
temp9 = deltaError * sum(abs(P)) - sum(abs(oldP - P));
temp10 = deltaError * sum(abs(C)) - sum(abs(oldC - C));
temp11 = deltaError * sum(abs(Lambda1)) - sum(abs(oldLambda1 -
Lambda1));
temp12 = deltaError * sum(abs(Lambda2)) - sum(abs(oldLambda2 -
Lambda2));
temp13 = deltaError * sum(abs(Lambda3)) - sum(abs(oldLambda3 -
Lambda3));
temp14 = deltaError * sum(abs(Lambda4)) - sum(abs(oldLambda4 -
Lambda4));
temp15 = deltaError * sum(abs(Lambda5)) - sum(abs(oldLambda5 -
Lambda5));
temp16 = deltaError * sum(abs(Lambda6)) - sum(abs(oldLambda6 -
Lambda6));

test = min(temp1,min(temp2,min(temp3,min(temp4, ...

min(temp5,min(temp6,min(temp7,min(temp8,min(temp9,min(temp10,min(tem
p11,min(temp12,min(temp13,min(temp14,min(temp15,temp16))))))))))))))
);
end
dy(1,:) = t; dy(2,:) = S; dy(3,:) = E; dy(4,:) = I;
dy(5,:) = L; dy(6,:) = R; dy(7,:) = V; dy(8,:) = P;
dy(9,:) = A; dy(10,:) = W; dy(11,:) = C; dy(12,:) = J;

plot(S); hold on;

hold off;
%axis([1 1200 0 42]);

148
Listing Program MATLAB untuk pemodelan penyakit Hepatits B tanpa kontrol
optimal

function dy = modelpenyakit(~)
% Parameters of the model
b = 0.0121; epsilon = 0.016;
alpha = 0.16; y = 0.00969075;
beta = 0.95; k = 0.0000684 ; mu = 0.002;
theta = 0.1; eta = 0.00125925;
m = 0.000693;

% Parameters of the Runge-Kutta (4th order) method

test = -1; deltaError = 0.001; M = 1000; T=5;
t = linspace(0,T,M+1);
h = T / M; h2 = h / 2; h6 = h / 6;
S = zeros(1,M+1); E = zeros(1,M+1);
I = zeros(1,M+1); L = zeros(1,M+1); R = zeros(1,M+1);
% Initial conditions of the model

S(1) =100; E(1) = 90; I(1) = 80; L(1) = 70; R(1) = 50; V(1) = 40;
% Iterations of the method
while(test < 0)
oldS = S; oldE = E; oldI = I; oldL = L; oldR = R;
%Forward Runge-Kutta iterations
for i = 1:M
% Differential equations of the model

% First Runge-Kutta parameter

aux3 = beta*I(i)*S(i);
aux4 = alpha*beta*L(i)*S(i);

auxS1 = b - (aux3+aux4) - m*S(i);

auxE1 = (aux3+aux4)- epsilon*E(i) - m*E(i);
auxI1 = epsilon*E(i) - y*I(i) - eta*I(i) - m*I(i);
auxL1 = y*I(i) - k*L(i) - m*L(i) - mu*L(i);
auxR1 = eta*I(i) + k*L(i) - m*R(i) ;

% Second Runge-Kutta parameter

auxSa = S(i) + h2 * auxS1; auxEa = E(i) + h2 * auxE1;
auxIa = I(i) + h2 * auxI1; auxLa = L(i) + h2 * auxL1; auxRa = R(i) +
h2 * auxR1;

aux3a = beta*auxIa*auxSa;
aux4a = alpha*beta*auxLa*auxSa;

auxS2 = b - (aux3a+aux4a) - m*auxSa;

auxE2 = (aux3a+aux4a)- epsilon*auxEa - m*auxEa;
auxI2 = epsilon*auxEa - y*auxIa - eta*auxIa - m*auxIa;
auxL2 = y*auxIa - k*auxLa - m*auxLa - mu*auxLa;
auxR2 = eta*auxIa + k*auxLa - m*auxRa ;

149
% Third Runge-Kutta parameter
auxSb = S(i) + h2 * auxS2; auxEb = E(i) + h2 * auxE2;
auxIb = I(i) + h2 * auxI2; auxLb = L(i) + h2 * auxL2; auxRb = R(i) +
h2 * auxR2;

aux3b = beta*auxIb*auxSb;
aux4b = alpha*beta*auxLb*auxSb;

auxS3 = b - (aux3b+aux4b) - m*auxSb;

auxE3 = (aux3b+aux4b)- epsilon*auxEb - m*auxEb;
auxI3 = epsilon*auxEb - y*auxIb - eta*auxIb - m*auxIb;
auxL3 = y*auxIb - k*auxLb - m*auxLb - mu*auxLb;
auxR3 = eta*auxIb + k*auxLb - m*auxRb ;

% Fourth Runge-Kutta parameter

auxSc = S(i) + h2 * auxS3; auxEc = E(i) + h2 * auxE3;
auxIc = I(i) + h2 * auxI3; auxLc = L(i) + h2 * auxL3; auxRc = R(i) +
h2 * auxR3;

aux3c = beta*auxIc*auxSc;
aux4c = alpha*beta*auxLc*auxSc;

auxS4 = b - (aux3c+aux4c) - m*auxSc;

auxE4 = (aux3c+aux4c)- epsilon*auxEc - m*auxEc;
auxI4 = epsilon*auxEc - y*auxIc - eta*auxIc - m*auxIc;
auxL4 = y*auxIc - k*auxLc - m*auxLc - mu*auxLc;
auxR4 = eta*auxIc + k*auxLc - m*auxRc ;

% Runge-Kutta new approximation

S(i+1) = S(i) + h6 * (auxS1 + 2 * (auxS2 + auxS3) + auxS4);
E(i+1) = E(i) + h6 * (auxE1 + 2 * (auxE2 + auxE3) + auxE4);
I(i+1) = I(i) + h6 * (auxI1 + 2 * (auxI2 + auxI3) + auxI4);
L(i+1) = L(i) + h6 * (auxL1 + 2 * (auxL2 + auxL3) + auxL4);
R(i+1) = R(i) + h6 * (auxR1 + 2 * (auxR2 + auxR3) + auxR4);
end
% Absolute error for convergence
temp1 = deltaError * sum(abs(S)) - sum(abs(oldS - S));
temp2 = deltaError * sum(abs(E)) - sum(abs(oldE - E));
temp3 = deltaError * sum(abs(I)) - sum(abs(oldI - I));
temp4 = deltaError * sum(abs(L)) - sum(abs(oldL - L));
temp5 = deltaError * sum(abs(R)) - sum(abs(oldR - R));

test = min(temp1,min(temp2,min(temp3,min(temp4,temp5))));
end
dy(1,:) = t; dy(2,:) = S; dy(3,:) = E;
dy(4,:) = I; dy(5,:) = L; dy(6,:) = R;
plot(I); hold on;

hold off;
%axis([1 1200 0 200]);

150