Shewhart-type monitoring schemes with supplementary w-of-w runs-rules to monitor the mean of autocorrelated samples

Abstract

The simplicity of the Shewhart $\overline{X}$ charts makes it popular in practice; however, it is insensitive to detecting small shifts. In an effort to preserve its simplicity but increase its detection ability, in this paper, we propose two Shewhart-type $\overline{X}$ charts supplemented with w-of-w runs-rules to monitor the mean of autocorrelated samples using a first-order autoregressive model. It is shown that the higher the level of autocorrelation, the poor the proposed schemes perform. Hence, we implement the skipping sampling strategy which involves sampling of nonconsecutive observations to form the rational subgroups to compute the corresponding sample means. The Markov chain approach is used to derive zero- and steady-state closed-form expressions of the average run-length (ARL). To supplement the specific shift performance metric, i.e. ARL, we compute the overall performance metric so that these schemes can also be evaluated from a global point of view. A real-life example is provided to illustrate the implementation of the monitoring schemes proposed here.

KEYWORDS:

• Shewhart charts
• Runs-rules
• Markov chain
• Zero-state
• Steady-state
• Skipping sampling strategy
• Transition probability matrix
• Autocorrelation

Acknowledgments

We would like to extend their gratitude to the Associate Editor and the two anonymous reviewers who read and evaluated our manuscript, and then gave constructive comments that led to an improved manuscript.

Some of the SAS® 9.4 programs used in the manuscript

• RR_w: Search algorithm for w and k in Steady-state

proc iml;

aa1 = J(1,3,.);

ARL_0 = 370.4; mu = 0; stdev = 1;

n = 1; phi = 0.0; s = 0; *Does not matter because shift = 0;

CC = sqrt(n/(n + 2*((phi**((s + 1)*(n + 1))-n*(phi**(2*(s + 1)))+(n-1)*phi**(s + 1))/((phi**(s + 1)-1)**2))));

w = 3;

tau = 2*w-1;

M = tau;

S_vector = J(1,M,.);

ARL_vector = J(M,1,.);

shift = 0;

/********************************************************************/

kmin = 0.5; kmax = 1.5; increment = 0.0001;

do k = kmin to kmax by increment;

A = 1-CDF("Normal",k,mu,stdev);

B = CDF("Normal",k,mu,stdev)-CDF("Normal",-k,mu,stdev);

C = CDF("Normal",-k,mu,stdev);

/*==========================================/

/*===(c) Insert the appropriate s vector for a given H===*/

p = A;

Mult=(1-p)/(1-p**w);

Mid = 1-((p-p**w)/(1-p));

S_vector[(tau + 1)/2]=Mult*Mid;

do j = 1 to w-1;

S_vector[j]=Mult*(p**(w-j));

S_vector[(tau + 1)-j]=Mult*(p**(w-j));

end;

Den=((1-B)*((1-A)*(1-C)))-(B*(((1-A)*(C-C**w))+((1-C)*(A-A**w))))-((1 + B)*((A-A**w)*(C-C**w)));

do j = 1 to w-1;

ARL_vector[j]=((1-A**j)*(1-C**w))/Den;

ARL_vector[(tau + 1)-j]=((1-C**j)*(1-A**w))/Den;

end;

ARL_vector[(tau + 1)/2]=((1-A**w)*(1-C**w))/Den;

SSARL = S_vector*ARL_vector;

/**********Grid or line search component of the code**********/

diff_SS = abs(SSARL-ARL_0);

aa = kǁSSARLǁdiff_SS;

aa1 = aa1//aa;

k_SSARL_diff_SS = aa1[2:nrow(aa1),];

call sort(k_SSARL_diff_SS,{3});

k_opt_SS = k_SSARL_diff_SS[1,1];

SSARL = k_SSARL_diff_SS[1,2];

/************************************************************/

end;

print w k_opt_SS SSARL; *this gives an w&k such that SSARL is approx.=ARL_0;

quit;

• Shewhart RR_w-of-w schemes – ZSARL & EARL

proc iml;

ARL_0 = 370.4; mu = 0; stdev = 1;

w = 6; k = 0.3644;

n = 10; phi = 0.0; s = 0;

CC = sqrt(n/(n + 2*((phi**((s + 1)*(n + 1))-n*(phi**(2*(s + 1)))+(n-1)*phi**(s + 1))/((phi**(s + 1)-1)**2))));

aa = J(1,2,.);

/******************************************************************/

deltamin = 0; deltamax = 3; increment = 0.25;

/********************************************************************/

do shift = deltamin to deltamax by increment;

A = 1-CDF("Normal",k-shift*sqrt(n)*CC,mu,stdev);

B = CDF("Normal",k-shift*sqrt(n)*CC,mu,stdev)-CDF("Normal",0-shift*sqrt(n)*CC,mu,stdev);

C = CDF("Normal",0-shift*sqrt(n)*CC,mu,stdev)-CDF("Normal",-k-shift*sqrt(n)*CC,mu,stdev);

D = CDF("Normal",-k-shift*sqrt(n)*CC,mu,stdev);

E = B + C;

O = 1-E;

/****************************************************************/

sumAA = 0;

sumDD = 0;

sumA = 0;

sumD = 0;

do i = 0 to w-1;

sumAA = sumAA + sum(A**i);

sumDD = sumDD + sum(D**i);

end;

do i = 1 to w-1;

sumA = sumA + sum(A**i);

sumD = sumD + sum(D**i);

end;

num = sumAA*sumDD;

denom = 1-E-E*sumA-E*sumD-E*sumA*sumD-sumA*sumD;

ZSARL = num/denom;

/*========================================*/

aa1 = shiftǁZSARL;

aa = aa//aa1;

Shift_ARL = aa[2:nrow(aa),2];

end;

EARL = Shift_ARL[+]/(deltamax-deltamin);

print w s, phi, Shift_ARL [label='ZSARL' format=.2];

print EARL [label='EARL' format=.1];

quit;

• Shewhart IRR_w-of-w schemes – ZSARL & EARL

proc iml;

ARL_0 = 370.4; mu = 0; stdev = 1;

w = 2;

n = 5; phi = 0.0; s = 0;

k1 = 4; k2 = 1.7866;

CC = sqrt(n/(n + 2*((phi**((s + 1)*(n + 1))-n*(phi**(2*(s + 1)))+(n-1)*phi**(s + 1))/((phi**(s + 1)-1)**2))));

aa = J(1,2,.);

/******************************************************************/

deltamin = 0; deltamax = 3; increment = 0.25;

/********************************************************************/

do shift = deltamin to deltamax by increment;

A = CDF("Normal",k1-shift*sqrt(n)*CC,mu,stdev)-CDF("Normal",k2-shift*sqrt(n)*CC,mu,stdev);

B = CDF("Normal",k2-shift*sqrt(n)*CC,mu,stdev)-CDF("Normal",0-shift*sqrt(n)*CC,mu,stdev);

C = CDF("Normal",0-shift*sqrt(n)*CC,mu,stdev)-CDF("Normal",-k2-shift*sqrt(n)*CC,mu,stdev);

D = CDF("Normal",-k2-shift*sqrt(n)*CC,mu,stdev)-CDF("Normal",-k1-shift*sqrt(n)*CC,mu,stdev);

E = B + C;

O = 1-E;

/**********************************************************/

sumAA = 0;

sumDD = 0;

sumA = 0;

sumD = 0;

do i = 0 to w-1;

sumAA = sumAA + sum(A**i);

sumDD = sumDD + sum(D**i);

end;

do i = 1 to w-1;

sumA = sumA + sum(A**i);

sumD = sumD + sum(D**i);

end;

num = sumAA*sumDD;

denom = 1-E-E*sumA-E*sumD-E*sumA*sumD-sumA*sumD;

ZSARL = num/denom;

/*===========================================*/

aa1 = shiftǁZSARL;

aa = aa//aa1;

Shift_ARL = aa[2:nrow(aa),2];

end;

EARL = Shift_ARL[+]/(deltamax-deltamin);

print w s, phi, Shift_ARL [label='ZSARL' format=.1];

print EARL [label='EARL' format=.1];

quit;

• Zero-state IRR₅: ARL, EARL and SDRL program

proc iml;

ARL_0 = 370.4; mu = 0; stdev = 1;

n = 10; phi = 0.5; s = 2;

w = 5;

k1 = 3.4;

k2 = 0.6179;

CC = sqrt(n/(n + 2*((phi**((s + 1)*(n + 1))-n*(phi**(2*(s + 1)))+(n-1)*phi**(s + 1))/((phi**(s + 1)-1)**2))));

/* Specifying the dimension of Q for each scheme*/

dim = 2*w-1;

tau = dim; kappa = 0; M = tau + kappa;

QQ = J(M,M,0);

Q = J(M,M,0);

aa = J(1,3,.);

one = J(M,1,1);

I = I(M);

*G = J(M,M,0);

S_vector = J(1,M,0);

S_vector[w]=1;

deltamin = 0.0; deltamax = 3; increment = 0.25;

do shift = deltamin to deltamax by increment;

p1 = 1-CDF("Normal",k1-shift*sqrt(n)*CC,mu,stdev);

p2 = CDF("Normal",k1-shift*sqrt(n)*CC,mu,stdev)-CDF("Normal",k2-shift*sqrt(n)*CC,mu,stdev);

p3 = CDF("Normal",k2-shift*sqrt(n)*CC,mu,stdev)-CDF("Normal",-k2-shift*sqrt(n)*CC,mu,stdev);

p4 = CDF("Normal",-k2-shift*sqrt(n)*CC,mu,stdev)-CDF("Normal",-k1-shift*sqrt(n)*CC,mu,stdev);

p5 = CDF("Normal",-k1-shift*sqrt(n)*CC,mu,stdev);

/*Insert here the appropriate essential TPM */

QQ[1,5]=p3; QQ[1,6]=p4;

QQ[2,1]=p2; QQ[2,5]=p3; QQ[2,6]=p4;

QQ[3,2]=p2; QQ[3,5]=p3; QQ[3,6]=p4;

QQ[4,3]=p2; QQ[4,5]=p3; QQ[4,6]=p4;

QQ[5,4]=p2; QQ[5,5]=p3; QQ[5,6]=p4;

QQ[6,4]=p2; QQ[6,5]=p3; QQ[6,7]=p4;

QQ[7,4]=p2; QQ[7,5]=p3; QQ[7,8]=p4;

QQ[8,4]=p2; QQ[8,5]=p3; QQ[8,9]=p4;

QQ[9,4]=p2; QQ[9,5]=p3;

ARL_vec=(inv(I-QQ))*one;

ZSARL = S_vector*ARL_vec;

QQ1 = inv(I-QQ);

Qone = QQ*one;

*SDRL=(2*S_vector*(QQ1**2)*Qone-ZSARL**2 + ZSARL)**0.5;

SDRL=(S_vector*(I + QQ)*(QQ1**2)*one-ZSARL**2)**(0.5);

/**********Grid or line search component of the code**********/

aa1 = shiftǁZSARLǁSDRL;

aa = aa//aa1;

Shift_ARL = aa[2:nrow(aa),];

end;

results = {"Shift" "ZSARL" "SDRL"};

EARL = Shift_ARL[+,2]/(deltamax-deltamin);

print n s phi, Shift_ARL [colname = results label = L format=.2];

print EARL [label='EARL' format=.1];

quit;

• Steady-state IRR₅: ARL, EARL and SDRL program

proc iml;

ARL_0 = 370.4; mu = 0; stdev = 1;

n = 5; phi = 0; s = 0; *Does not matter since the shift = 0;

w = 5;

k = 0.5694;

CC = sqrt(n/(n + 2*((phi**((s + 1)*(n + 1))-n*(phi**(2*(s + 1)))+(n-1)*phi**(s + 1))/((phi**(s + 1)-1)**2))));

/* Specifying the dimension of Q for each scheme*/

dimNSS = 2*w-1; *S(NSS);

tau = dimNSS; kappa = 0; M = tau + kappa;

QQ = J(M,M,0);

Q = J(M,M,0);

aa = J(1,3,.);

one = J(M,1,1);

I = I(M);

G = J(M,M,0);

do j = 1 to M;

G[j,j]=1;

end;

G[w,]=1;

G[w,w]=2;

u = J(M,1,0);

u[w]=1;

/********************************************************************/

A = 1-CDF("Normal",k,mu,stdev);

B = CDF("Normal",k,mu,stdev)-CDF("Normal",-k,mu,stdev);

C = CDF("Normal",-k,mu,stdev);

/*Insert here the appropriate essential TPM */

Q[1,5]=B; Q[1,6]=C;

Q[2,1]=A; Q[2,5]=B; Q[2,6]=C;

Q[3,2]=A; Q[3,5]=B; Q[3,6]=C;

Q[4,3]=A; Q[4,5]=B; Q[4,6]=C;

Q[5,4]=A; Q[5,5]=B; Q[5,6]=C;

Q[6,4]=A; Q[6,5]=B; Q[6,7]=C;

Q[7,4]=A; Q[7,5]=B; Q[7,8]=C;

Q[8,4]=A; Q[8,5]=B; Q[8,9]=C;

Q[9,4]=A; Q[9,5]=B;

/*======================================*/

z = inv(G-(Q)`)*u;

s = inv((one)`*z)*z;

deltamin = 0.0; deltamax = 3; increment = 0.25;

do shift = deltamin to deltamax by increment;

A1 = 1-CDF("Normal",k-shift*sqrt(n)*CC,mu,stdev);

B1 = CDF("Normal",k-shift*sqrt(n)*CC,mu,stdev)-CDF("Normal",-k-shift*sqrt(n)*CC,mu,stdev);

C1 = CDF("Normal",-k-shift*sqrt(n)*CC,mu,stdev);

/*Insert here the appropriate essential TPM */

QQ[1,5]=B1; QQ[1,6]=C1;

QQ[2,1]=A1; QQ[2,5]=B1; QQ[2,6]=C1;

QQ[3,2]=A1; QQ[3,5]=B1; QQ[3,6]=C1;

QQ[4,3]=A1; QQ[4,5]=B1; QQ[4,6]=C1;

QQ[5,4]=A1; QQ[5,5]=B1; QQ[5,6]=C1;

QQ[6,4]=A1; QQ[6,5]=B1; QQ[6,7]=C1;

QQ[7,4]=A1; QQ[7,5]=B1; QQ[7,8]=C1;

QQ[8,4]=A1; QQ[8,5]=B1; QQ[8,9]=C1;

QQ[9,4]=A1; QQ[9,5]=B1;

ARL_vec=(inv(I-QQ))*one;

SSARL = s`*ARL_vec;

QQ1 = inv(I-QQ);

Qone = QQ*one;

*SDRL=(2*s`*(QQ1**2)*Qone-SSARL**2 + SSARL)**0.5;

SDRL=(s`*(I + QQ)*(QQ1**2)*one-SSARL**2)**0.5;

/**********Grid or line search component of the code**********/

aa1 = shiftǁSSARLǁSDRL;

aa = aa//aa1;

Shift_ARL = aa[2:nrow(aa),];

end;

results = {"Shift" "SSARl" "SDRL"};

EARL = Shift_ARL[+,2]/(deltamax-deltamin);

print phi, Shift_ARL [colname = results label = L format=.2];

print EARL [label='EARL' format=.1]; quit;